@streamr/trackerless-network 100.0.0-testnet-three.5 → 100.0.0

package/src/logic/protocol-integration/stream-message/StreamMessageTranslator.ts

@@ -7,11 +7,7 @@ import {
     StreamID,
     EncryptionType as OldEncryptionType,
     SignatureType as OldSignatureType,
-    ContentType as OldContentType,
-    serializeGroupKeyRequest as serializeOldGroupKeyRequest,
-    serializeGroupKeyResponse as serializeOldGroupKeyResponse,
-    deserializeGroupKeyRequest as deserializeOldGroupKeyRequest,
-    deserializeGroupKeyResponse as deserializeOldGroupKeyResponse
+    ContentType as OldContentType
 } from '@streamr/protocol'
 import {
     ContentType,
@@ -22,12 +18,9 @@ import {
     MessageRef,
     SignatureType,
     StreamMessage,
-    StreamMessageType,
     MessageID
 } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { toEthereumAddress, binaryToHex, hexToBinary } from '@streamr/utils'
-import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
-import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
 
 const oldToNewEncryptionType = (type: OldEncryptionType): EncryptionType => {
     if (type === OldEncryptionType.AES) {
@@ -76,24 +69,6 @@ const newToOldSignatureType = (type: SignatureType): OldSignatureType => {
 export class StreamMessageTranslator {
 
     static toProtobuf(msg: OldStreamMessage): StreamMessage {
-        let content: Uint8Array
-        let messageType: StreamMessageType
-        if (msg.messageType === OldStreamMessageType.MESSAGE) {
-            content = msg.content
-            messageType = StreamMessageType.MESSAGE
-        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
-            content = GroupKeyRequest.toBinary(
-                GroupKeyRequestTranslator.toProtobuf(deserializeOldGroupKeyRequest(msg.content))
-            )
-            messageType = StreamMessageType.GROUP_KEY_REQUEST
-        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
-            content = GroupKeyResponse.toBinary(
-                GroupKeyResponseTranslator.toProtobuf(deserializeOldGroupKeyResponse(msg.content))
-            )
-            messageType = StreamMessageType.GROUP_KEY_RESPONSE
-        } else {
-            throw new Error('invalid message type')
-        }
         const messageId: MessageID = {
             timestamp: msg.getTimestamp(),
             sequenceNumber: msg.getSequenceNumber(),
@@ -106,52 +81,81 @@ export class StreamMessageTranslator {
         if (msg.prevMsgRef) {
             previousMessageRef = {
                 timestamp: msg.prevMsgRef.timestamp,
-                sequenceNumber: msg.prevMsgRef.sequenceNumber,
+                sequenceNumber: msg.prevMsgRef.sequenceNumber
             }
         }
-        let newGroupKey: GroupKey | undefined = undefined
-        if (msg.newGroupKey) {
-            newGroupKey = {
-                id: msg.newGroupKey.id,
-                data: msg.newGroupKey.data
+        let body: StreamMessage['body']
+        if (msg.messageType === OldStreamMessageType.MESSAGE) {
+            let newGroupKey: GroupKey | undefined = undefined
+            if (msg.newGroupKey) {
+                newGroupKey = {
+                    id: msg.newGroupKey.id,
+                    data: msg.newGroupKey.data
+                }
+            }
+            body = {
+                oneofKind: 'contentMessage',
+                contentMessage: {
+                    content: msg.content,
+                    contentType: oldToNewContentType(msg.contentType),
+                    encryptionType: oldToNewEncryptionType(msg.encryptionType),
+                    groupKeyId: msg.groupKeyId ?? undefined,
+                    newGroupKey
+                }
+            }
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
+            body = {
+                oneofKind: 'groupKeyRequest',
+                groupKeyRequest: GroupKeyRequest.fromBinary(msg.content)
+            }
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
+            body = {
+                oneofKind: 'groupKeyResponse',
+                groupKeyResponse: GroupKeyResponse.fromBinary(msg.content)
             }
+        } else {
+            throw new Error('invalid message type')
         }
         const translated: StreamMessage = {
             messageId,
             previousMessageRef,
-            content,
-            messageType,
-            contentType: oldToNewContentType(msg.contentType),
-            encryptionType: oldToNewEncryptionType(msg.encryptionType),
-            groupKeyId: msg.groupKeyId ?? undefined,
-            newGroupKey,
             signature: msg.signature,
             signatureType: oldToNewSignatureType(msg.signatureType),
+            body
         }
         return translated
     }
 
     static toClientProtocol(msg: StreamMessage): OldStreamMessage {
-        let content: Uint8Array
         let messageType: OldStreamMessageType
-        if (msg.messageType === StreamMessageType.MESSAGE) {
+        let content: Uint8Array
+        let contentType: OldContentType = OldContentType.BINARY
+        let encryptionType: OldEncryptionType = OldEncryptionType.NONE
+        let newGroupKey: OldEncryptedGroupKey | undefined = undefined
+        let groupKeyId: string | undefined = undefined
+        if (msg.body.oneofKind === 'contentMessage') {
             messageType = OldStreamMessageType.MESSAGE
-            content = msg.content
-        } else if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
+            content = msg.body.contentMessage.content
+            contentType = newToOldContentType(msg.body.contentMessage.contentType)
+            encryptionType = newToOldEncryptionType(msg.body.contentMessage.encryptionType)
+            if (msg.body.contentMessage.newGroupKey) {
+                newGroupKey = new OldEncryptedGroupKey(
+                    msg.body.contentMessage.newGroupKey.id,
+                    msg.body.contentMessage.newGroupKey.data
+                )
+            }
+            groupKeyId = msg.body.contentMessage.groupKeyId
+        } else if (msg.body.oneofKind === 'groupKeyRequest') {
             messageType = OldStreamMessageType.GROUP_KEY_REQUEST
             try {
-                const parsedRequest = GroupKeyRequest.fromBinary(msg.content)
-                const oldGroupKeyRequest = GroupKeyRequestTranslator.toClientProtocol(parsedRequest)
-                content = serializeOldGroupKeyRequest(oldGroupKeyRequest)
+                content = GroupKeyRequest.toBinary(msg.body.groupKeyRequest)
             } catch (err) {
                 throw new Error(`invalid group key request: ${err}`)
             }
-        } else if (msg.messageType === StreamMessageType.GROUP_KEY_RESPONSE) {
+        } else if (msg.body.oneofKind === 'groupKeyResponse') {
             messageType = OldStreamMessageType.GROUP_KEY_RESPONSE
             try {
-                const parsedResponse = GroupKeyResponse.fromBinary(msg.content)
-                const oldGroupKeyResponse = GroupKeyResponseTranslator.toClientProtocol(parsedResponse)
-                content = serializeOldGroupKeyResponse(oldGroupKeyResponse)
+                content = GroupKeyResponse.toBinary(msg.body.groupKeyResponse)
             } catch (err) {
                 throw new Error(`invalid group key response: ${err}`)
             }
@@ -170,24 +174,17 @@ export class StreamMessageTranslator {
         if (msg.previousMessageRef) {
             prevMsgRef = new OldMessageRef(Number(msg.previousMessageRef.timestamp), msg.previousMessageRef.sequenceNumber)
         }
-        let newGroupKey: OldEncryptedGroupKey | undefined = undefined
-        if (msg.newGroupKey) {
-            newGroupKey = new OldEncryptedGroupKey(
-                msg.newGroupKey.id,
-                msg.newGroupKey.data,
-            )
-        }
         const translated = new OldStreamMessage({
             messageId,
             prevMsgRef,
-            content,
             messageType,
-            contentType: newToOldContentType(msg.contentType),
-            encryptionType: newToOldEncryptionType(msg.encryptionType),
-            groupKeyId: msg.groupKeyId,
-            newGroupKey,
+            content,
+            contentType,
             signature: msg.signature,
-            signatureType: newToOldSignatureType(msg.signatureType)
+            signatureType: newToOldSignatureType(msg.signatureType),
+            encryptionType,
+            groupKeyId,
+            newGroupKey
         })
         return translated
     }

package/src/logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils.ts

@@ -1,6 +1,16 @@
-import { StreamMessage as OldStreamMessage } from '@streamr/protocol'
+import { 
+    StreamMessage as OldStreamMessage,
+    GroupKeyRequest as OldGroupKeyRequest,
+    GroupKeyResponse as OldGroupKeyResponse
+} from '@streamr/protocol'
 import { StreamMessageTranslator } from './StreamMessageTranslator'
-import { StreamMessage } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import {
+    StreamMessage,
+    GroupKeyRequest,
+    GroupKeyResponse
+} from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
+import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
 
 export function convertStreamMessageToBytes(oldStreamMessage: OldStreamMessage): Uint8Array {
     return StreamMessage.toBinary(StreamMessageTranslator.toProtobuf(oldStreamMessage))
@@ -9,3 +19,19 @@ export function convertStreamMessageToBytes(oldStreamMessage: OldStreamMessage):
 export function convertBytesToStreamMessage(bytes: Uint8Array): OldStreamMessage {
     return StreamMessageTranslator.toClientProtocol(StreamMessage.fromBinary(bytes))
 }
+
+export const convertGroupKeyRequestToBytes = (oldGroupKeyRequest: OldGroupKeyRequest): Uint8Array => {
+    return GroupKeyRequest.toBinary(GroupKeyRequestTranslator.toProtobuf(oldGroupKeyRequest))
+}
+
+export const convertBytesToGroupKeyRequest = (bytes: Uint8Array): OldGroupKeyRequest => {
+    return GroupKeyRequestTranslator.toClientProtocol(GroupKeyRequest.fromBinary(bytes))
+}
+
+export const convertGroupKeyResponseToBytes = (oldGroupKeyResponse: OldGroupKeyResponse): Uint8Array => {
+    return GroupKeyResponse.toBinary(GroupKeyResponseTranslator.toProtobuf(oldGroupKeyResponse))
+}
+
+export const convertBytesToGroupKeyResponse = (bytes: Uint8Array): OldGroupKeyResponse => {
+    return GroupKeyResponseTranslator.toClientProtocol(GroupKeyResponse.fromBinary(bytes))
+}

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -1,11 +1,9 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { 
-    GroupKeyRequest,
     ProxyConnectionRequest,
     ProxyConnectionResponse,
     ProxyDirection,
-    StreamMessage,
-    StreamMessageType
+    StreamMessage
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
@@ -64,9 +62,9 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
     }
 
     getPropagationTargets(msg: StreamMessage): DhtAddress[] {
-        if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
+        if (msg.body.oneofKind === 'groupKeyRequest') {
             try {
-                const recipientId = GroupKeyRequest.fromBinary(msg.content).recipientId
+                const recipientId = msg.body.groupKeyRequest.recipientId
                 return this.getNodeIdsForUserId(toEthereumAddress(binaryToHex(recipientId, true)))
             } catch (err) {
                 logger.trace(`Could not parse GroupKeyRequest: ${err}`)

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

@@ -5,27 +5,33 @@ import {
     TemporaryConnectionResponse
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../proto/google/protobuf/empty'
+import { StreamPartID } from '@streamr/protocol'
 
 interface TemporaryConnectionRpcLocalConfig {
     rpcCommunicator: ListeningRpcCommunicator
     localPeerDescriptor: PeerDescriptor
+    streamPartId: StreamPartID
+    connectionLocker: ConnectionLocker
 } 
 
+const LOCK_ID_BASE = 'system/delivery/temporary-connection/'
+
 export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     private readonly config: TemporaryConnectionRpcLocalConfig
     private readonly temporaryNodes: NodeList
-
+    private readonly lockId: string
     constructor(config: TemporaryConnectionRpcLocalConfig) {
         this.config = config
         // TODO use config option or named constant?
         this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.localPeerDescriptor), 10)
+        this.lockId = LOCK_ID_BASE + config.streamPartId
     }
 
     getNodes(): NodeList {
@@ -38,6 +44,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     removeNode(nodeId: DhtAddress): void {
         this.temporaryNodes.remove(nodeId)
+        this.config.connectionLocker.weakUnlockConnection(nodeId, this.lockId)
     }
 
     async openConnection(
@@ -52,6 +59,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
             DeliveryRpcClient
         )
         this.temporaryNodes.add(remote)
+        this.config.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(sender), this.lockId)
         return {
             accepted: true
         }

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

@@ -4,8 +4,8 @@
 import { ExternalApiRpc } from "./DhtRpc";
 import type { ExternalStoreDataResponse } from "./DhtRpc";
 import type { ExternalStoreDataRequest } from "./DhtRpc";
-import type { ExternalFindDataResponse } from "./DhtRpc";
-import type { ExternalFindDataRequest } from "./DhtRpc";
+import type { ExternalFetchDataResponse } from "./DhtRpc";
+import type { ExternalFetchDataRequest } from "./DhtRpc";
 import { ConnectionLockRpc } from "./DhtRpc";
 import type { DisconnectNotice } from "./DhtRpc";
 import type { UnlockRequest } from "./DhtRpc";
@@ -352,9 +352,9 @@ export class ConnectionLockRpcClient implements IConnectionLockRpcClient, Servic
  */
 export interface IExternalApiRpcClient {
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse>;
+    externalFetchData(input: ExternalFetchDataRequest, options?: RpcOptions): UnaryCall<ExternalFetchDataRequest, ExternalFetchDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */
@@ -370,11 +370,11 @@ export class ExternalApiRpcClient implements IExternalApiRpcClient, ServiceInfo
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse> {
+    externalFetchData(input: ExternalFetchDataRequest, options?: RpcOptions): UnaryCall<ExternalFetchDataRequest, ExternalFetchDataResponse> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<ExternalFindDataRequest, ExternalFindDataResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<ExternalFetchDataRequest, ExternalFetchDataResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);

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

@@ -3,8 +3,8 @@
 // tslint:disable
 import { ExternalStoreDataResponse } from "./DhtRpc";
 import { ExternalStoreDataRequest } from "./DhtRpc";
-import { ExternalFindDataResponse } from "./DhtRpc";
-import { ExternalFindDataRequest } from "./DhtRpc";
+import { ExternalFetchDataResponse } from "./DhtRpc";
+import { ExternalFetchDataRequest } from "./DhtRpc";
 import { DisconnectNotice } from "./DhtRpc";
 import { UnlockRequest } from "./DhtRpc";
 import { LockResponse } from "./DhtRpc";
@@ -140,9 +140,9 @@ export interface IConnectionLockRpc<T = ServerCallContext> {
  */
 export interface IExternalApiRpc<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(request: ExternalFindDataRequest, context: T): Promise<ExternalFindDataResponse>;
+    externalFetchData(request: ExternalFetchDataRequest, context: T): Promise<ExternalFetchDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */