@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/src/connection/websocket/AbstractWebsocketClientConnection.ts

@@ -1,122 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { createRandomConnectionId } from '../Connection'
-import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from '../IConnection'
-import { Logger } from '@streamr/utils'
-
-export interface Socket {
-    binaryType: string
-    readyState: number
-    close(code?: number, reason?: string): void
-    send(data: string | Buffer | ArrayBuffer | ArrayBufferView): void
-}
-
-// https://kapeli.com/cheat_sheets/WebSocket_Status_Codes.docset/Contents/Resources/Documents/index
-// Browsers send this automatically when closing a tab
-export const GOING_AWAY = 1001
-// The GOING_AWAY is a reserved code and we shouldn't send that from the application. Therefore
-// we have a custom counterpart
-export const CUSTOM_GOING_AWAY = 3001
-// https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants
-const OPEN = 1
-
-const logger = new Logger(module)
-
-export abstract class AbstractWebsocketClientConnection extends EventEmitter<ConnectionEvents> implements IConnection {
-
-    public readonly connectionId: ConnectionID
-    protected abstract socket?: Socket
-    public connectionType = ConnectionType.WEBSOCKET_CLIENT
-    protected destroyed = false
-    
-    constructor() {
-        super()
-        this.connectionId = createRandomConnectionId()
-    }
-
-    // TODO explicit default value for "selfSigned" or make it required
-    public abstract connect(address: string, allowSelfSignedCertificate: boolean): void
-    
-    protected abstract stopListening(): void
-
-    public send(data: Uint8Array): void {
-        if (!this.destroyed) {
-            if (this.socket && this.socket.readyState === OPEN) {
-                logger.trace(`Sending data with size ${data.byteLength}`)
-                this.socket?.send(data)
-            } else {
-                // Could this throw for faster feedback on RPC calls?
-                // Currently this log line is seen if a connection is closing but the disconnected event has not been emitted yet.
-                logger.debug('Tried to send data on a non-open connection', { 
-                    id: this.connectionId,
-                    readyState: this.socket!.readyState,
-                    destroyed: this.destroyed
-                })
-            }
-        } else {
-            logger.debug('Tried to send() on stopped connection')
-        }
-    }
-
-    public async close(gracefulLeave: boolean): Promise<void> {
-        this.emit('disconnected', gracefulLeave, undefined, 'close() called')
-        this.removeAllListeners()
-        if (!this.destroyed) {
-            logger.trace(`Closing socket for connection ${this.connectionId}`)
-            this.socket?.close(gracefulLeave ? CUSTOM_GOING_AWAY : undefined)
-        } else {
-            logger.debug('Tried to close() a stopped connection', { id: this.connectionId })
-        }
-    }
-
-    public destroy(): void {
-        logger.trace('destroy() a connection')
-        if (!this.destroyed) {
-            this.removeAllListeners()
-            if (this.socket) {
-                this.stopListening()
-                this.socket.close()
-                this.socket = undefined
-            }
-            this.destroyed = true
-        } else {
-            logger.debug('Tried to destroy() a stopped connection')
-        }
-    }
-
-    protected onOpen(): void {
-        if (!this.destroyed) {
-            logger.trace('WebSocket Client Connected')
-            if (this.socket && this.socket.readyState === OPEN) {
-                this.emit('connected')
-            }
-        }
-    }
-
-    protected onMessage(message: Uint8Array): void {
-        this.emit('data', message)
-    }
-
-    protected onClose(code: number, reason: string): void {
-        if (!this.destroyed) {
-            logger.trace('Websocket Closed')
-            this.doDisconnect(code, reason)
-        }
-    }
-
-    protected onError(error: Error): void {
-        if (!this.destroyed) {
-            logger.trace('WebSocket Client error: ' + error?.message, { error })
-            this.emit('error', error.name)
-        }
-    }
-
-    protected doDisconnect(code?: number, reason?: string): void {
-        this.destroyed = true
-        this.stopListening()
-        this.socket = undefined
-        const gracefulLeave = (code === GOING_AWAY) || (code === CUSTOM_GOING_AWAY)
-        this.emit('disconnected', gracefulLeave, code, reason)
-        this.removeAllListeners()
-    }
-
-}

package/src/connection/websocket/AutoCertifierClientFacade.ts

@@ -1,89 +0,0 @@
-import {
-    AutoCertifierClient,
-    HasSessionRequest,
-    HasSessionResponse, 
-    CertifiedSubdomain,
-    SERVICE_ID as AUTO_CERTIFIER_SERVICE_ID,
-    HasSession
-} from '@streamr/autocertifier-client'
-import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { Logger, waitForEvent3 } from '@streamr/utils'
-import { ITransport } from '../../transport/ITransport' 
-
-const START_TIMEOUT = 60 * 1000
-
-const defaultAutoCertifierClientFactory = (
-    configFile: string,
-    autoCertifierUrl: string,
-    autoCertifierRpcCommunicator: ListeningRpcCommunicator,
-    wsServerPort: number
-) => new AutoCertifierClient(
-    configFile,
-    wsServerPort,
-    autoCertifierUrl, 
-    (_serviceId: string, rpcMethodName: string, method: HasSession) => {
-        autoCertifierRpcCommunicator.registerRpcMethod(
-            HasSessionRequest,
-            HasSessionResponse,
-            rpcMethodName,
-            method
-        )                       
-    }
-)
-
-export interface IAutoCertifierClient {
-    start(): Promise<void>
-    stop(): void
-    on(eventName: string, cb: (subdomain: CertifiedSubdomain) => void): void
-}
-
-interface AutoCertifierClientFacadeOptions {
-    url: string
-    configFile: string
-    transport: ITransport
-    wsServerPort: number
-    // TODO: setHost and updateCertificate could be passed in a single onCertificateUpdated function.
-    setHost: (host: string) => void
-    updateCertificate: (certificate: string, privateKey: string) => void
-    // TOD: could just pass the client?
-    createClientFactory?: () => IAutoCertifierClient
-}
-
-const logger = new Logger(module)
-
-export class AutoCertifierClientFacade {
-
-    private autoCertifierClient: IAutoCertifierClient
-    private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly options: AutoCertifierClientFacadeOptions
-
-    constructor(options: AutoCertifierClientFacadeOptions) {
-        this.options = options
-        this.rpcCommunicator = new ListeningRpcCommunicator(AUTO_CERTIFIER_SERVICE_ID, options.transport)
-        this.autoCertifierClient = options.createClientFactory ? options.createClientFactory() 
-            : defaultAutoCertifierClientFactory(
-                options.configFile,
-                options.url,
-                this.rpcCommunicator,
-                options.wsServerPort
-            )
-    }
-
-    async start(): Promise<void> {
-        this.autoCertifierClient.on('updatedCertificate', (subdomain: CertifiedSubdomain) => {
-            this.options.setHost(subdomain.fqdn)
-            this.options.updateCertificate(subdomain.certificate, subdomain.privateKey)
-            logger.trace(`Updated certificate`)
-        })
-        await Promise.all([
-            waitForEvent3(this.autoCertifierClient as any, 'updatedCertificate', START_TIMEOUT),
-            this.autoCertifierClient.start()
-        ])
-    }
-
-    stop(): void {
-        this.autoCertifierClient.stop()
-        this.rpcCommunicator.destroy()
-    }
-
-}

package/src/connection/websocket/BrowserWebsocketClientConnection.ts

@@ -1,44 +0,0 @@
-import { Logger } from '@streamr/utils'
-import { ICloseEvent, IMessageEvent, w3cwebsocket as Websocket } from 'websocket'
-import { AbstractWebsocketClientConnection } from './AbstractWebsocketClientConnection'
-
-const logger = new Logger(module)
-
-const BINARY_TYPE = 'arraybuffer'
-
-export class WebsocketClientConnection extends AbstractWebsocketClientConnection {
-
-    protected socket?: Websocket 
-
-    // TODO explicit default value for "selfSigned" or make it required
-    public connect(address: string, selfSigned?: boolean): void {
-        if (!this.destroyed) {
-            this.socket = new Websocket(address, undefined, undefined, undefined, { rejectUnauthorized: !selfSigned })
-            this.socket.binaryType = BINARY_TYPE
-            this.socket.onerror = (error: Error) => this.onError(error)
-            this.socket.onopen = () => this.onOpen()
-            this.socket.onclose = (event: ICloseEvent) => this.onClose(event.code, event.reason)
-            this.socket.onmessage = (message: IMessageEvent) => {
-                if (!this.destroyed) {
-                    if (typeof message.data === 'string') {
-                        logger.debug('Received string data, only binary data is supported')
-                    } else {
-                        this.onMessage(new Uint8Array(message.data))
-                    }
-                }
-            }
-        } else {
-            logger.debug('Tried to connect() a stopped connection')
-        }
-    }
-
-    protected stopListening(): void {
-        if (this.socket) {
-            this.socket.onopen = undefined as unknown as (() => void)
-            this.socket.onclose = undefined as unknown as (() => void)
-            this.socket.onerror = undefined as unknown as (() => void)
-            this.socket.onmessage = undefined as unknown as (() => void)
-        }
-    }
-
-}

package/src/connection/websocket/NodeWebsocketClientConnection.ts

@@ -1,39 +0,0 @@
-import { Logger, binaryToUtf8 } from '@streamr/utils'
-import { WebSocket } from 'ws'
-import { AbstractWebsocketClientConnection } from './AbstractWebsocketClientConnection'
-
-const logger = new Logger(module)
-
-const BINARY_TYPE = 'nodebuffer'
-
-export class WebsocketClientConnection extends AbstractWebsocketClientConnection {
-
-    protected socket?: WebSocket
-
-    // TODO explicit default value for "selfSigned" or make it required
-    public connect(address: string, selfSigned?: boolean): void {
-        if (!this.destroyed) {
-            this.socket = new WebSocket(address, { rejectUnauthorized: !selfSigned })
-            this.socket.binaryType = BINARY_TYPE
-            this.socket.on('error', (error: Error) => this.onError(error))
-            this.socket.on('open', () => this.onOpen())
-            this.socket.on('close', (code: number, reason: Buffer) => this.onClose(code, binaryToUtf8(reason)))
-            this.socket.on('message', (message: Buffer, isBinary: boolean) => {
-                if (!this.destroyed) {
-                    if (isBinary === false) {
-                        logger.debug('Received string data, only binary data is supported')
-                    } else {
-                        this.onMessage(new Uint8Array(message))
-                    }
-                }
-            })
-        } else {
-            logger.debug('Tried to connect() a stopped connection', { id: this.connectionId })
-        }
-    }
-
-    protected stopListening(): void {
-        this.socket?.removeAllListeners()
-    }
-
-}

package/src/connection/websocket/WebsocketClientConnector.ts

@@ -1,119 +0,0 @@
-import { WebsocketClientConnection } from './NodeWebsocketClientConnection'
-import { ConnectionType } from '../IConnection'
-import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
-import { WebsocketClientConnectorRpcLocal } from './WebsocketClientConnectorRpcLocal'
-import {
-    ConnectivityMethod,
-    PeerDescriptor,
-    WebsocketConnectionRequest
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { WebsocketServer } from './WebsocketServer'
-import { createOutgoingHandshaker } from '../Handshaker'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { expectedConnectionType } from '../../helpers/Connectivity'
-import { Empty } from '../../../generated/google/protobuf/empty'
-import { DhtAddress, toNodeId } from '../../identifiers'
-import { GeoIpLocator } from '@streamr/geoip-location'
-import { PendingConnection } from '../PendingConnection'
-
-export type Action = 'connectivityRequest' | 'connectivityProbe'
-
-export const connectivityMethodToWebsocketUrl = (ws: ConnectivityMethod, action?: Action): string => {
-    return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port + ((action !== undefined) ? '?action=' + action : '')
-}
-
-export interface WebsocketClientConnectorOptions {
-    onNewConnection: (connection: PendingConnection) => boolean
-    hasConnection: (nodeId: DhtAddress) => boolean
-    rpcCommunicator: ListeningRpcCommunicator
-}
-
-export class WebsocketClientConnector {
-
-    public static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
-    private readonly websocketServer?: WebsocketServer
-    private geoIpLocator?: GeoIpLocator
-
-    private localPeerDescriptor?: PeerDescriptor
-    private connectingConnections: Map<DhtAddress, PendingConnection> = new Map()
-    private abortController = new AbortController()
-    private readonly options: WebsocketClientConnectorOptions
-
-    constructor(options: WebsocketClientConnectorOptions) {
-        this.options = options
-        
-        this.registerLocalRpcMethods()
-    }
-
-    private registerLocalRpcMethods() {
-        const rpcLocal = new WebsocketClientConnectorRpcLocal({
-            connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
-            hasConnection: (nodeId: DhtAddress): boolean => (this.connectingConnections.has(nodeId)
-                || this.options.hasConnection(nodeId))
-            ,
-            onNewConnection: (connection: PendingConnection) => this.options.onNewConnection(connection),
-            abortSignal: this.abortController.signal
-        })
-        this.options.rpcCommunicator.registerRpcNotification(
-            WebsocketConnectionRequest,
-            'requestConnection',
-            async (req: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> => {
-                if (!this.abortController.signal.aborted) {
-                    return rpcLocal.requestConnection(req, context)
-                } else {
-                    return {}
-                }
-            }
-        )
-    }
-
-    public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
-        const connectionType = expectedConnectionType(this.localPeerDescriptor!, targetPeerDescriptor)
-        return connectionType === ConnectionType.WEBSOCKET_CLIENT
-    }
-
-    public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
-        const nodeId = toNodeId(targetPeerDescriptor)
-        const existingConnection = this.connectingConnections.get(nodeId)
-        if (existingConnection) {
-            return existingConnection
-        }
-        const socket = new WebsocketClientConnection()
-
-        const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
-
-        const pendingConnection = new PendingConnection(targetPeerDescriptor)
-        createOutgoingHandshaker(this.localPeerDescriptor!, pendingConnection, socket, targetPeerDescriptor)
-        this.connectingConnections.set(nodeId, pendingConnection)
-
-        const delFunc = () => {
-            if (this.connectingConnections.has(nodeId)) {
-                this.connectingConnections.delete(nodeId)
-            }
-            socket.off('disconnected', delFunc)
-            pendingConnection.off('disconnected', delFunc)
-            pendingConnection.off('connected', delFunc)
-        }
-        socket.on('disconnected', delFunc)
-        pendingConnection.on('disconnected', delFunc)
-        pendingConnection.on('connected', delFunc)
-
-        socket.connect(url, false)
-
-        return pendingConnection
-    }
-    
-    public setLocalPeerDescriptor(peerDescriptor: PeerDescriptor): void {
-        this.localPeerDescriptor = peerDescriptor
-    }
-
-    public async destroy(): Promise<void> {
-        this.abortController.abort()
-
-        const requests = Array.from(this.connectingConnections.values())
-        await Promise.allSettled(requests.map((conn) => conn.close(true)))
-
-        await this.websocketServer?.stop()
-        this.geoIpLocator?.stop()
-    }
-}

package/src/connection/websocket/WebsocketClientConnectorRpcLocal.ts

@@ -1,38 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import {
-    PeerDescriptor,
-    WebsocketConnectionRequest
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { IWebsocketClientConnectorRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
-import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-import { Empty } from '../../../generated/google/protobuf/empty'
-import { toNodeId, DhtAddress } from '../../identifiers'
-import { PendingConnection } from '../PendingConnection'
-
-interface WebsocketClientConnectorRpcLocalOptions {
-    connect: (targetPeerDescriptor: PeerDescriptor) => PendingConnection
-    hasConnection: (nodeId: DhtAddress) => boolean
-    onNewConnection: (connection: PendingConnection) => boolean
-    abortSignal: AbortSignal
-}
-
-export class WebsocketClientConnectorRpcLocal implements IWebsocketClientConnectorRpc {
-
-    private readonly options: WebsocketClientConnectorRpcLocalOptions
-
-    constructor(options: WebsocketClientConnectorRpcLocalOptions) {
-        this.options = options
-    }
-
-    public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<Empty> {
-        if (this.options.abortSignal.aborted) {
-            return {}
-        }
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (!this.options.hasConnection(toNodeId(senderPeerDescriptor))) {
-            const connection = this.options.connect(senderPeerDescriptor)
-            this.options.onNewConnection(connection)
-        }
-        return {}
-    }
-}

package/src/connection/websocket/WebsocketClientConnectorRpcRemote.ts

@@ -1,19 +0,0 @@
-import {
-    WebsocketConnectionRequest
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { Logger } from '@streamr/utils'
-import { RpcRemote } from '../../dht/contact/RpcRemote'
-import { WebsocketClientConnectorRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
-import { toNodeId } from '../../identifiers'
-
-const logger = new Logger(module)
-
-export class WebsocketClientConnectorRpcRemote extends RpcRemote<WebsocketClientConnectorRpcClient> {
-
-    async requestConnection(): Promise<void> {
-        logger.trace(`Requesting WebSocket connection from ${toNodeId(this.getLocalPeerDescriptor())}`)
-        const request: WebsocketConnectionRequest = {}
-        const options = this.formDhtRpcOptions()
-        return this.getClient().requestConnection(request, options)
-    }
-}

package/src/connection/websocket/WebsocketServer.ts

@@ -1,164 +0,0 @@
-import { createServer as createHttpServer, Server as HttpServer, IncomingMessage, ServerResponse } from 'http'
-import { createServer as createHttpsServer, Server as HttpsServer } from 'https'
-import EventEmitter from 'eventemitter3'
-import WebSocket from 'ws'
-import { WebsocketServerConnection } from './WebsocketServerConnection'
-import { Logger, asAbortable } from '@streamr/utils'
-import { createSelfSignedCertificate } from '@streamr/autocertifier-client' 
-import { WebsocketServerStartError } from '../../helpers/errors'
-import { PortRange, TlsCertificate } from '../ConnectionManager'
-import { range } from 'lodash'
-import fs from 'fs'
-import { v4 as uuid } from 'uuid'
-import { parse } from 'url'
-import { IConnection } from '../IConnection'
-
-const logger = new Logger(module)
-
-interface WebsocketServerOptions {
-    portRange: PortRange
-    enableTls: boolean
-    tlsCertificate?: TlsCertificate
-    maxMessageSize?: number
-}
-
-interface Events {
-    connected: ((connection: IConnection) => void) 
-}
-
-export class WebsocketServer extends EventEmitter<Events> {
-
-    private httpServer?: HttpServer | HttpsServer
-    private wsServer?: WebSocket.Server
-    private readonly abortController = new AbortController()
-    private readonly options: WebsocketServerOptions
-
-    constructor(options: WebsocketServerOptions) {
-        super()
-        this.options = options
-    }
-
-    public async start(): Promise<number> {
-        const ports = range(this.options.portRange.min, this.options.portRange.max + 1)
-        for (const port of ports) {
-            try {
-                await asAbortable(this.startServer(port, this.options.enableTls), this.abortController.signal)
-                return port
-            } catch (err) {
-                if (err.originalError?.code === 'EADDRINUSE') {
-                    logger.debug(`failed to start WebSocket server on port: ${port} reattempting on next port`)
-                } else {
-                    throw new WebsocketServerStartError(err)
-                }
-            }
-        }
-        throw new WebsocketServerStartError(
-            `Failed to start WebSocket server on any port in range: ${this.options.portRange.min}-${this.options.portRange.min}`
-        )
-    }
-
-    // If tlsCertificate has been given the tls boolean is ignored
-    // TODO: could be simplified?
-    private startServer(port: number, tls: boolean): Promise<void> {
-        const requestListener = (request: IncomingMessage, response: ServerResponse<IncomingMessage>) => {
-            logger.trace('Received request for ' + request.url)
-            response.writeHead(404)
-            response.end()
-        }
-        return new Promise((resolve, reject) => {
-            if (this.options.tlsCertificate) {
-                this.httpServer = createHttpsServer({
-                    key: fs.readFileSync(this.options.tlsCertificate.privateKeyFileName),
-                    cert: fs.readFileSync(this.options.tlsCertificate.certFileName)
-                }, requestListener)
-            } else if (!tls) {
-                this.httpServer = createHttpServer(requestListener)
-            } else {
-                // TODO use options option or named constant?
-                const certificate = createSelfSignedCertificate('streamr-self-signed-' + uuid(), 1000)
-                this.httpServer = createHttpsServer({
-                    key: certificate.serverKey,
-                    cert: certificate.serverCert
-                }, requestListener)
-            }
-
-            function originIsAllowed() {
-                return true
-            }
-
-            this.wsServer = this.createWsServer()
-            
-            this.wsServer.on('connection', (ws: WebSocket, request: IncomingMessage) => {
-                logger.trace(`New connection from ${request.socket.remoteAddress}`)
-                if (!originIsAllowed()) {
-                    // Make sure we only accept requests from an allowed origin
-                    ws.close()
-                    logger.trace('IConnection from origin ' + request.headers.origin + ' rejected.')
-                    return
-                }
-                this.emit('connected', new WebsocketServerConnection(ws, parse(request.url!), request.socket.remoteAddress!))
-            })
-
-            this.httpServer.on('upgrade', (request, socket, head) => {
-                logger.trace('Received upgrade request for ' + request.url)
-                this.wsServer!.handleUpgrade(request, socket, head, (ws: WebSocket) => {
-                    this.wsServer!.emit('connection', ws, request)
-                })
-            })
-
-            this.httpServer.once('error', (err: Error) => {
-                reject(new WebsocketServerStartError('Starting Websocket server failed', err))
-            })
-
-            this.httpServer.once('listening', () => {
-                logger.debug('Websocket server is listening on port ' + port)
-                resolve()
-            })
-
-            try {
-                // Listen only to IPv4 network interfaces, default value listens to IPv6 as well
-                this.httpServer.listen(port, '0.0.0.0')
-            } catch (e) {
-                reject(new WebsocketServerStartError('Websocket server threw an exception', e))
-            }
-        })
-    }
-
-    public updateCertificate(cert: string, key: string): void {
-        (this.httpServer! as HttpsServer).setSecureContext({
-            cert,
-            key
-        })
-    }
-
-    public stop(): Promise<void> {
-        this.abortController.abort()
-        this.removeAllListeners()
-        return new Promise((resolve, _reject) => {
-            this.wsServer!.close()
-            for (const ws of this.wsServer!.clients) {
-                ws.terminate()
-            }
-            this.httpServer?.once('close', () => {
-                // removeAllListeners is maybe not needed?
-                this.httpServer?.removeAllListeners()
-                resolve()
-            })
-            this.httpServer?.close()
-            // the close method "Stops the server from accepting new connections and closes all 
-            // connections connected to this server which are not sending a request or waiting for a 
-            // response." (https://nodejs.org/api/http.html#serverclosecallback)
-            // i.e. we need to call closeAllConnections() to close the rest of the connections
-            // (in practice this closes the active websocket connections)
-            this.httpServer?.closeAllConnections()
-        })
-    }
-
-    private createWsServer(): WebSocket.Server {
-        const maxPayload = this.options.maxMessageSize ?? 1048576
-        return this.wsServer = new WebSocket.Server({
-            noServer: true,
-            maxPayload
-        })
-    }
-}