@dcl/protocol 1.0.0-6725457366.commit-d6b2b77 → 1.0.0-7117237552.commit-82dc93b

package/out-ts/decentraland/kernel/apis/communications_controller.gen.ts

@@ -10,6 +10,14 @@ export interface RealSendRequest {
 export interface RealSendResponse {
 }
 
+export interface SendBinaryRequest {
+  data: Uint8Array[];
+}
+
+export interface SendBinaryResponse {
+  data: Uint8Array[];
+}
+
 function createBaseRealSendRequest(): RealSendRequest {
   return { message: "" };
 }
@@ -110,6 +118,126 @@ export namespace RealSendResponse {
   }
 }
 
+function createBaseSendBinaryRequest(): SendBinaryRequest {
+  return { data: [] };
+}
+
+export namespace SendBinaryRequest {
+  export function encode(message: SendBinaryRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SendBinaryRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendBinaryRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SendBinaryRequest {
+    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [] };
+  }
+
+  export function toJSON(message: SendBinaryRequest): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SendBinaryRequest>, I>>(base?: I): SendBinaryRequest {
+    return SendBinaryRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SendBinaryRequest>, I>>(object: I): SendBinaryRequest {
+    const message = createBaseSendBinaryRequest();
+    message.data = object.data?.map((e) => e) || [];
+    return message;
+  }
+}
+
+function createBaseSendBinaryResponse(): SendBinaryResponse {
+  return { data: [] };
+}
+
+export namespace SendBinaryResponse {
+  export function encode(message: SendBinaryResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SendBinaryResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendBinaryResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SendBinaryResponse {
+    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [] };
+  }
+
+  export function toJSON(message: SendBinaryResponse): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SendBinaryResponse>, I>>(base?: I): SendBinaryResponse {
+    return SendBinaryResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SendBinaryResponse>, I>>(object: I): SendBinaryResponse {
+    const message = createBaseSendBinaryResponse();
+    message.data = object.data?.map((e) => e) || [];
+    return message;
+  }
+}
+
 export type CommunicationsControllerServiceDefinition = typeof CommunicationsControllerServiceDefinition;
 export const CommunicationsControllerServiceDefinition = {
   name: "CommunicationsControllerService",
@@ -127,9 +255,61 @@ export const CommunicationsControllerServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    sendBinary: {
+      name: "SendBinary",
+      requestType: SendBinaryRequest,
+      requestStream: false,
+      responseType: SendBinaryResponse,
+      responseStream: false,
+      options: {},
+    },
   },
 } as const;
 
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = tsProtoGlobalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return tsProtoGlobalThis.btoa(bin.join(""));
+  }
+}
+
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 
 export type DeepPartial<T> = T extends Builtin ? T

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-6725457366.commit-d6b2b77",
+  "version": "1.0.0-7117237552.commit-82dc93b",
   "description": "",
   "repository": "decentraland/protocol.git",
   "homepage": "https://github.com/decentraland/protocol#readme",
@@ -29,5 +29,5 @@
     "out-js",
     "public"
   ],
-  "commit": "d6b2b77a0b41121ec754642ee378d7a892132989"
+  "commit": "82dc93b03ed77a4fb15e62655e97bd1f74ad8170"
 }

package/proto/decentraland/kernel/apis/communications_controller.proto

@@ -2,13 +2,22 @@ syntax = "proto3";
 package decentraland.kernel.apis;
 
 message RealSendRequest {
-    string message = 1;
+  string message = 1;
 }
 
 message RealSendResponse {}
 
+message SendBinaryRequest {
+  repeated bytes data = 1;
+}
+
+message SendBinaryResponse {
+  repeated bytes data = 1;
+}
+
 service CommunicationsControllerService {
-    // @deprecated - This API should use a bidirectional binary stream in sdk7
-    // https://github.com/decentraland/sdk/issues/582
-    rpc Send(RealSendRequest) returns (RealSendResponse) {}
+  // @deprecated - This API should use a bidirectional binary stream in sdk7
+  // https://github.com/decentraland/sdk/issues/582
+  rpc Send(RealSendRequest) returns (RealSendResponse) {}
+  rpc SendBinary(SendBinaryRequest) returns (SendBinaryResponse) {}
 }