@streamr/trackerless-network 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

package/src/logic/StreamrNode.ts

@@ -140,12 +140,7 @@ export class StreamrNode extends EventEmitter<Events> {
             layer1Node,
             getEntryPointData: (key) => this.layer0Node!.getDataFromDht(key),
             storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
-            deleteEntryPointData: async (key) => {
-                if (this.destroyed) {
-                    return 
-                }
-                return this.layer0Node!.deleteDataFromDht(key)
-            }
+            deleteEntryPointData: async (key: Uint8Array) => this.layer0Node!.deleteDataFromDht(key, false)
         })
         streamPart = {
             proxied: false,
@@ -225,6 +220,7 @@ export class StreamrNode extends EventEmitter<Events> {
         userId: EthereumAddress,
         connectionCount?: number
     ): Promise<void> {
+        // TODO explicit default value for "acceptProxyConnections" or make it required
         if (this.config.acceptProxyConnections) {
             throw new Error('cannot set proxies when acceptProxyConnections=true')
         }
@@ -313,6 +309,7 @@ export class StreamrNode extends EventEmitter<Events> {
 
 [`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `unhandledRejection`, `SIGTERM`].forEach((term) => {
     process.on(term, async () => {
+        // TODO should we catch possible promise rejection?
         await cleanUp()
         process.exit()
     })

package/src/logic/neighbor-discovery/HandshakeRpcRemote.ts

@@ -1,4 +1,4 @@
-import { PeerDescriptor, Remote } from '@streamr/dht'
+import { PeerDescriptor, RpcRemote } from '@streamr/dht'
 import { Logger, hexToBinary } from '@streamr/utils'
 import { v4 } from 'uuid'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
@@ -12,7 +12,7 @@ interface HandshakeResponse {
     interleaveTargetDescriptor?: PeerDescriptor
 }
 
-export class HandshakeRpcRemote extends Remote<IHandshakeRpcClient> {
+export class HandshakeRpcRemote extends RpcRemote<IHandshakeRpcClient> {
 
     async handshake(
         neighborIds: NodeID[],

package/src/logic/neighbor-discovery/Handshaker.ts

@@ -98,6 +98,7 @@ export class Handshaker implements IHandshaker {
         const results = await Promise.allSettled(
             Array.from(targets.values()).map(async (target: HandshakeRpcRemote, i) => {
                 const otherNode = i === 0 ? targets[1] : targets[0]
+                // TODO better check (currently this condition is always true)
                 const otherNodeId = otherNode ? getNodeIdFromPeerDescriptor(otherNode.getPeerDescriptor()) : undefined
                 return this.handshakeWithTarget(target, otherNodeId)
             })

package/src/logic/neighbor-discovery/NeighborFinder.ts

@@ -34,6 +34,7 @@ export class NeighborFinder implements INeighborFinder {
         }
         const newExcludes = await this.config.doFindNeighbors(excluded)
         if (this.config.targetNeighbors.size() < this.config.minCount && newExcludes.length < this.config.nearbyNodeView.size()) {
+            // TODO should we catch possible promise rejection?
             setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
         } else {
             this.running = false
@@ -49,6 +50,7 @@ export class NeighborFinder implements INeighborFinder {
             return
         }
         this.running = true
+        // TODO should we catch possible promise rejection?
         setAbortableTimeout(() => this.findNeighbors(excluded), INITIAL_WAIT, this.abortController.signal)
     }
 

package/src/logic/neighbor-discovery/NeighborUpdateRpcRemote.ts

@@ -1,4 +1,4 @@
-import { PeerDescriptor, Remote } from '@streamr/dht'
+import { PeerDescriptor, RpcRemote } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
@@ -11,7 +11,7 @@ interface UpdateNeighborsResponse {
     removeMe: boolean
 }
 
-export class NeighborUpdateRpcRemote extends Remote<INeighborUpdateRpcClient> {
+export class NeighborUpdateRpcRemote extends RpcRemote<INeighborUpdateRpcClient> {
 
     async updateNeighbors(neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
         const request: NeighborUpdate = {

package/src/logic/propagation/Propagation.ts

@@ -65,6 +65,7 @@ export class Propagation {
 
     private sendAndAwaitThenMark({ message, source, handledNeighbors }: PropagationTask, neighborId: NodeID): void {
         if (!handledNeighbors.has(neighborId) && neighborId !== source) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             (async () => {
                 try {
                     await this.sendToNeighbor(neighborId, message)

package/src/logic/proxy/ProxyClient.ts

@@ -86,6 +86,7 @@ export class ProxyClient extends EventEmitter {
             onLeaveNotice: (senderId: NodeID) => {
                 const contact = this.targetNeighbors.get(senderId)
                 if (contact) {
+                    // TODO should we catch possible promise rejection?
                     setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()))
                 }
             },
@@ -121,9 +122,9 @@ export class ProxyClient extends EventEmitter {
     ): Promise<void> {
         logger.trace('Setting proxies', { streamPartId: this.config.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
         if (connectionCount !== undefined && connectionCount > nodes.length) {
-            throw Error('Cannot set connectionCount above the size of the configured array of nodes')
+            throw new Error('Cannot set connectionCount above the size of the configured array of nodes')
         }
-        const nodesIds = new Map()
+        const nodesIds = new Map<NodeID, PeerDescriptor>()
         nodes.forEach((peerDescriptor) => {
             nodesIds.set(getNodeIdFromPeerDescriptor(peerDescriptor), peerDescriptor)
         })
@@ -243,6 +244,7 @@ export class ProxyClient extends EventEmitter {
         addManagedEventListener<any, any>(
             this.config.transport as any,
             'disconnected',
+            // TODO should we catch possible promise rejection?
             (peerDescriptor: PeerDescriptor) => this.onNodeDisconnected(peerDescriptor),
             this.abortController.signal
         )

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -1,11 +1,11 @@
-import { Remote, EXISTING_CONNECTION_TIMEOUT } from '@streamr/dht'
+import { RpcRemote, EXISTING_CONNECTION_TIMEOUT } from '@streamr/dht'
 import { EthereumAddress, Logger, hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRequest, ProxyDirection } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
-export class ProxyConnectionRpcRemote extends Remote<IProxyConnectionRpcClient> {
+export class ProxyConnectionRpcRemote extends RpcRemote<IProxyConnectionRpcClient> {
 
     async requestConnection(direction: ProxyDirection, userId: EthereumAddress): Promise<boolean> {
         const request: ProxyConnectionRequest = {

package/src/logic/temporary-connection/TemporaryConnectionRpcRemote.ts

@@ -1,11 +1,11 @@
-import { Remote } from '@streamr/dht'
+import { RpcRemote } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { ITemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
-export class TemporaryConnectionRpcRemote extends Remote<ITemporaryConnectionRpcClient> {
+export class TemporaryConnectionRpcRemote extends RpcRemote<ITemporaryConnectionRpcClient> {
 
     async openConnection(): Promise<boolean> {
         try {

package/src/proto/packages/dht/protos/DhtRpc.client.ts

@@ -23,10 +23,7 @@ import type { WebsocketConnectionRequest } from "./DhtRpc";
 import { FindSessionRpc } from "./DhtRpc";
 import type { FindResponse } from "./DhtRpc";
 import { StoreRpc } from "./DhtRpc";
-import type { DeleteDataResponse } from "./DhtRpc";
-import type { DeleteDataRequest } from "./DhtRpc";
-import type { MigrateDataResponse } from "./DhtRpc";
-import type { MigrateDataRequest } from "./DhtRpc";
+import type { ReplicateDataRequest } from "./DhtRpc";
 import type { StoreDataResponse } from "./DhtRpc";
 import type { StoreDataRequest } from "./DhtRpc";
 import { FindRpc } from "./DhtRpc";
@@ -165,13 +162,9 @@ export interface IStoreRpcClient {
      */
     storeData(input: StoreDataRequest, options?: RpcOptions): UnaryCall<StoreDataRequest, StoreDataResponse>;
     /**
-     * @generated from protobuf rpc: migrateData(dht.MigrateDataRequest) returns (dht.MigrateDataResponse);
+     * @generated from protobuf rpc: replicateData(dht.ReplicateDataRequest) returns (google.protobuf.Empty);
      */
-    migrateData(input: MigrateDataRequest, options?: RpcOptions): UnaryCall<MigrateDataRequest, MigrateDataResponse>;
-    /**
-     * @generated from protobuf rpc: deleteData(dht.DeleteDataRequest) returns (dht.DeleteDataResponse);
-     */
-    deleteData(input: DeleteDataRequest, options?: RpcOptions): UnaryCall<DeleteDataRequest, DeleteDataResponse>;
+    replicateData(input: ReplicateDataRequest, options?: RpcOptions): UnaryCall<ReplicateDataRequest, Empty>;
 }
 /**
  * @generated from protobuf service dht.StoreRpc
@@ -190,18 +183,11 @@ export class StoreRpcClient implements IStoreRpcClient, ServiceInfo {
         return stackIntercept<StoreDataRequest, StoreDataResponse>("unary", this._transport, method, opt, input);
     }
     /**
-     * @generated from protobuf rpc: migrateData(dht.MigrateDataRequest) returns (dht.MigrateDataResponse);
+     * @generated from protobuf rpc: replicateData(dht.ReplicateDataRequest) returns (google.protobuf.Empty);
      */
-    migrateData(input: MigrateDataRequest, options?: RpcOptions): UnaryCall<MigrateDataRequest, MigrateDataResponse> {
+    replicateData(input: ReplicateDataRequest, options?: RpcOptions): UnaryCall<ReplicateDataRequest, Empty> {
         const method = this.methods[1], opt = this._transport.mergeOptions(options);
-        return stackIntercept<MigrateDataRequest, MigrateDataResponse>("unary", this._transport, method, opt, input);
-    }
-    /**
-     * @generated from protobuf rpc: deleteData(dht.DeleteDataRequest) returns (dht.DeleteDataResponse);
-     */
-    deleteData(input: DeleteDataRequest, options?: RpcOptions): UnaryCall<DeleteDataRequest, DeleteDataResponse> {
-        const method = this.methods[2], opt = this._transport.mergeOptions(options);
-        return stackIntercept<DeleteDataRequest, DeleteDataResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<ReplicateDataRequest, Empty>("unary", this._transport, method, opt, input);
     }
 }
 /**

package/src/proto/packages/dht/protos/DhtRpc.server.ts

@@ -17,10 +17,7 @@ import { WebrtcConnectionRequest } from "./DhtRpc";
 import { WebsocketConnectionResponse } from "./DhtRpc";
 import { WebsocketConnectionRequest } from "./DhtRpc";
 import { FindResponse } from "./DhtRpc";
-import { DeleteDataResponse } from "./DhtRpc";
-import { DeleteDataRequest } from "./DhtRpc";
-import { MigrateDataResponse } from "./DhtRpc";
-import { MigrateDataRequest } from "./DhtRpc";
+import { ReplicateDataRequest } from "./DhtRpc";
 import { StoreDataResponse } from "./DhtRpc";
 import { StoreDataRequest } from "./DhtRpc";
 import { RouteMessageAck } from "./DhtRpc";
@@ -80,13 +77,9 @@ export interface IStoreRpc<T = ServerCallContext> {
      */
     storeData(request: StoreDataRequest, context: T): Promise<StoreDataResponse>;
     /**
-     * @generated from protobuf rpc: migrateData(dht.MigrateDataRequest) returns (dht.MigrateDataResponse);
+     * @generated from protobuf rpc: replicateData(dht.ReplicateDataRequest) returns (google.protobuf.Empty);
      */
-    migrateData(request: MigrateDataRequest, context: T): Promise<MigrateDataResponse>;
-    /**
-     * @generated from protobuf rpc: deleteData(dht.DeleteDataRequest) returns (dht.DeleteDataResponse);
-     */
-    deleteData(request: DeleteDataRequest, context: T): Promise<DeleteDataResponse>;
+    replicateData(request: ReplicateDataRequest, context: T): Promise<Empty>;
 }
 /**
  * @generated from protobuf service dht.FindSessionRpc