@dcl/protocol 1.0.0-2861824890.commit-748eb8b → 1.0.0-28806326790.commit-6771b13

package/out-ts/google/protobuf/empty.gen.ts

@@ -0,0 +1,72 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "google.protobuf";
+
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ */
+export interface Empty {
+}
+
+function createBaseEmpty(): Empty {
+  return {};
+}
+
+export namespace Empty {
+  export function encode(_: Empty, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Empty {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEmpty();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): Empty {
+    return {};
+  }
+
+  export function toJSON(_: Empty): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Empty>, I>>(base?: I): Empty {
+    return Empty.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Empty>, I>>(_: I): Empty {
+    const message = createBaseEmpty();
+    return message;
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };

package/out-ts/quests.gen.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+export const protobufPackage = "decentraland.quests";

package/out-ts/sdk-apis.gen.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+export const protobufPackage = "decentraland.sdk";

package/out-ts/sdk-components.gen.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+export const protobufPackage = "decentraland.sdk.components";

package/out-ts/sdk-development.gen.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+export const protobufPackage = "decentraland.sdk.development";

package/out-ts/social.gen.ts

@@ -0,0 +1,3 @@
+/* eslint-disable */
+
+export const protobufPackage = "decentraland.social";

package/package.json

@@ -1,21 +1,40 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-2861824890.commit-748eb8b",
+  "version": "1.0.0-28806326790.commit-6771b13",
   "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/decentraland/protocol.git"
   },
+  "homepage": "https://github.com/decentraland/protocol#readme",
+  "bugs": "https://github.com/decentraland/protocol/issues",
   "keywords": [],
   "author": "",
   "license": "Apache-2.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "./scripts/check-proto-compabitility.sh",
+    "gen:test": "node protoc-gen-bitwise/test/generator.test.js"
+  },
   "devDependencies": {
-    "proto-compatibility-tool": "^1.1.1-20220811001836.commit-414739b"
+    "@protobuf-ts/protoc": "^2.11.0",
+    "proto-compatibility-tool": "^1.1.2-20220925163655.commit-25bd040",
+    "typescript": "^5.0.4"
+  },
+  "config": {
+    "protocVersion": "22.2"
+  },
+  "dependencies": {
+    "@dcl/ts-proto": "1.154.0",
+    "protobufjs": "7.2.4"
   },
   "files": [
-    "kernel",
-    "renderer-protocol",
-    "ecs"
+    "proto/decentraland",
+    "out-ts",
+    "out-js",
+    "public",
+    "protoc-gen-bitwise/*.js",
+    "protoc-gen-bitwise/runtime"
   ],
-  "commit": "748eb8b6a5a7c535f66d664fff12fdbb205570c1"
+  "commit": "6771b13b653788fc5dc5d0d69d6df22a1ca341ca"
 }

package/proto/decentraland/common/border_rect.proto

@@ -0,0 +1,18 @@
+syntax = "proto3";
+package decentraland.common;
+
+// Defines indents from respective edges
+message BorderRect {
+  float top = 1;
+  float left = 2;
+  float right = 3;
+  float bottom = 4;
+}
+
+// Defines a rect with x, y, width and height
+message Rect {
+  float x = 1;
+  float y = 2;
+  float width = 3;
+  float height = 4;
+}

package/proto/decentraland/common/colors.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+package decentraland.common;
+
+message Color3 {
+  float r = 1;
+  float g = 2;
+  float b = 3;
+}
+
+message Color4 {
+  float r = 1;
+  float g = 2;
+  float b = 3;
+  float a = 4;
+}
+
+// A range of Color4 values. Randomized or lerped between start and end.
+message ColorRange {
+  Color4 start = 1;
+  Color4 end = 2;
+}

package/{kernel/apis/common/ContentMapping.proto → proto/decentraland/common/content_mapping.proto}

@@ -1,4 +1,5 @@
 syntax = "proto3";
+package decentraland.common;
 
 message ContentMapping {
     string file = 1;

package/proto/decentraland/common/entity.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+package decentraland.common;
+import "decentraland/common/content_mapping.proto";
+
+// Entity schema compliant with https://rfc.decentraland.org/adr/ADR-80
+
+message Entity {
+  string id = 1;
+  repeated string pointers = 2;
+  string metadata = 3;
+  uint32 timestamp = 4;
+  repeated ContentMapping content = 5;
+}

package/proto/decentraland/common/floats.proto

@@ -0,0 +1,8 @@
+syntax = "proto3";
+package decentraland.common;
+
+// A range of float values. Randomized or lerped between start and end.
+message FloatRange {
+  float start = 1;
+  float end = 2;
+}

package/proto/decentraland/common/options.proto

@@ -0,0 +1,51 @@
+syntax = "proto3";
+
+package decentraland.common;
+
+import "google/protobuf/descriptor.proto";
+
+// Options for quantizing a float value stored as a uint32 field.
+// The float is clamped to [min, max] and uniformly quantized to N bits;
+// protobuf encodes the resulting uint32 as a varint on the wire.
+// The generator emits a float {Name}Quantized accessor in the partial class.
+message QuantizedFloatOptions {
+  float  min  = 1;
+  float  max  = 2;
+  uint32 bits = 3;
+}
+
+// Options for quantizing a signed float with a power-law curve, stored as a uint32 field.
+// The value is split into an (bits-1)-bit linear unorm magnitude `u in [0, 1]` plus a sign,
+// and reconstructed as `value = sign * max * u^pow`. Because `u = 0` maps to exactly `0`, zero is
+// representable (unlike the linear quantizer, whose codes straddle zero), and `pow > 1` concentrates
+// resolution near zero — useful for fields like velocity that need fine detail at low magnitudes and
+// only coarse detail near the extremes. The range is symmetric ([-max, max]); there is no `min`.
+// The encoded layout puts the magnitude in the high bits and the sign in the LSB
+// (`(magnitude << 1) | sign`), so the varint cost tracks magnitude, not direction: a small `|value|`
+// of either sign stays in one varint byte. Zero canonicalizes to `0`, so proto3 omits a stopped field.
+// The generator emits a float {Name}Quantized accessor, same as the linear option.
+message QuantizedPowerFloatOptions {
+  float  max  = 1;
+  float  pow  = 2;
+  uint32 bits = 3;
+}
+
+// Options for bit-packing an integer field into fewer than 32 bits.
+message BitPackedOptions {
+  uint32 bits = 1;
+}
+
+extend google.protobuf.FieldOptions {
+  // Apply to uint32 fields to enable quantized float encoding.
+  // Example: uint32 dx = 1 [(decentraland.common.quantized) = { min: -100.0, max: 100.0, bits: 16 }];
+  QuantizedFloatOptions quantized  = 50001;
+
+  // Apply to uint32 fields to pack into fewer bits.
+  // Example: uint32 entity_id = 4 [(decentraland.common.bit_packed) = { bits: 20 }];
+  BitPackedOptions      bit_packed = 50002;
+
+  // Apply to uint32 fields to enable power-law quantized float encoding (sign + magnitude curve).
+  // A field carries either `quantized` or `quantized_power`, not both.
+  // Example: uint32 velocity_x = 9 [(decentraland.common.quantized_power) = { max: 50.0, pow: 2.0, bits: 8 }];
+  QuantizedPowerFloatOptions quantized_power = 50003;
+}

package/proto/decentraland/common/quantization_example.proto

@@ -0,0 +1,164 @@
+syntax = "proto3";
+
+package decentraland.common;
+
+import "decentraland/common/options.proto";
+
+// High-frequency player state messages sent on Channel 1 (unreliable sequenced).
+//
+// Every message below uses the protoc-gen-bitwise annotations to minimise
+// wire size.  Wire costs are listed per-message so the trade-offs are clear.
+//
+// Annotation cheat-sheet:
+//   [(decentraland.common.quantized)  = { min: F, max: F, bits: N }]
+//       → stores a float as a uint32 quantized to N bits over [min, max].
+//       → protobuf encodes the uint32 as a varint: values ≤ 2^14-1 cost 2 bytes,
+//         values ≤ 2^21-1 cost 3 bytes; the generated partial class adds a
+//         float {Name}Quantized accessor that encodes/decodes transparently.
+//   [(decentraland.common.quantized_power) = { max: F, pow: F, bits: N }]
+//       → stores a signed float over [-max, max] as an (N-1)-bit linear unorm
+//         magnitude (high bits) plus a sign (LSB), reconstructed as sign·max·u^pow.
+//         Zero is exact, and pow>1 buys fine resolution near zero at the cost of
+//         coarse near ±max. Putting the sign in the LSB keeps a small |value| of
+//         either direction in one varint byte. Same generated float {Name}Quantized
+//         accessor as the linear option.
+//   [(decentraland.common.bit_packed) = { bits: N }]
+//       → documents that this uint32 uses at most N bits; protobuf encodes it
+//         as a varint (same savings, no generated accessor needed).
+//   (no annotation)
+//       → standard protobuf encoding (bool/double/etc. at natural width).
+//
+// Varint byte costs at worst-case (all bits set):
+//   ≤ 7 bits  → 1 byte   (max 127)
+//   ≤ 14 bits → 2 bytes  (max 16 383)
+//   ≤ 21 bits → 3 bytes  (max 2 097 151)
+// Proto3 omits fields equal to their default value (0), so average cost is lower.
+
+// ---------------------------------------------------------------------------
+// PositionDelta — Δ position relative to last acknowledged full snapshot.
+//
+// Sent every client tick (~10 Hz) on Channel 1.
+//
+//  Field       | Type   | Range          | Q bits | Wire worst-case
+//  ------------|--------|----------------|--------|-----------------------
+//  dx          | uint32 | [-100, 100]    |   16   | tag 1B + varint 3B = 4B
+//  dy          | uint32 | [-100, 100]    |   16   | tag 1B + varint 3B = 4B
+//  dz          | uint32 | [-100, 100]    |   16   | tag 1B + varint 3B = 4B
+//  entity_id   | uint32 | [0, 1 048 575] |   20   | tag 1B + varint 3B = 4B
+//  sequence    | uint32 | [0,     4 095] |   12   | tag 1B + varint 2B = 3B
+//  ---------------------------------------------------------------------------
+//  Worst-case: 19 B  (vs. 20 B raw: 3×float + 2×uint32)
+//  Step: dx/dy/dz ≈ 0.003 units
+// ---------------------------------------------------------------------------
+message PositionDelta {
+  uint32 dx        = 1 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 dy        = 2 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 dz        = 3 [(decentraland.common.quantized)  = { min: -100.0, max: 100.0, bits: 16 }];
+  uint32 entity_id = 4 [(decentraland.common.bit_packed) = { bits: 20 }];
+  uint32 sequence  = 5 [(decentraland.common.bit_packed) = { bits: 12 }];
+}
+
+// ---------------------------------------------------------------------------
+// PlayerInput — client input snapshot for server-side reconciliation.
+//
+// Sent every client frame (~30 Hz) on Channel 1.
+//
+//  Field       | Type   | Range          | Q bits | Wire worst-case
+//  ------------|--------|----------------|--------|-----------------------
+//  move_x      | uint32 | [-1, 1]        |    8   | tag 1B + varint 2B = 3B
+//  move_z      | uint32 | [-1, 1]        |    8   | tag 1B + varint 2B = 3B
+//  yaw         | uint32 | [-180, 180]    |   12   | tag 1B + varint 2B = 3B
+//  buttons     | uint32 | bitmask        |    8   | tag 1B + varint 2B = 3B
+//  sequence    | uint32 | [0, 4 095]     |   12   | tag 1B + varint 2B = 3B
+//  ---------------------------------------------------------------------------
+//  Worst-case: 15 B  (vs. 20 B raw: 3×float + 2×uint32)
+//  Step: move_x/move_z ≈ 0.008; yaw ≈ 0.088°
+// ---------------------------------------------------------------------------
+message PlayerInput {
+  // Normalised joystick axes in [-1, 1].
+  uint32 move_x   = 1 [(decentraland.common.quantized)  = { min: -1.0,   max: 1.0,   bits:  8 }];
+  uint32 move_z   = 2 [(decentraland.common.quantized)  = { min: -1.0,   max: 1.0,   bits:  8 }];
+
+  // Horizontal look direction in degrees.
+  uint32 yaw      = 3 [(decentraland.common.quantized)  = { min: -180.0, max: 180.0, bits: 12 }];
+
+  // Bitmask of active buttons (see ButtonFlags below).
+  uint32 buttons  = 4 [(decentraland.common.bit_packed) = { bits:  8 }];
+
+  // Rolling input sequence number used by the server for reconciliation.
+  uint32 sequence = 5 [(decentraland.common.bit_packed) = { bits: 12 }];
+}
+
+// ---------------------------------------------------------------------------
+// VelocityState — per-axis velocity, demonstrating the power-law quantizer.
+//
+// Velocity needs an exact zero (a stopped avatar must read 0, not a quantization
+// residual, or it drifts) and fine resolution at locomotion speeds, but only
+// coarse resolution near the ±50 m/s extremes. The linear quantizer can give
+// none of these from 8 bits: its codes straddle zero (±0.196) and spend uniform
+// resolution on speeds that never occur. quantized_power solves all three.
+//
+//  Field  | Type   | Range      | pow | bits | Wire worst-case
+//  -------|--------|------------|-----|------|-----------------------
+//  vx     | uint32 | [-50, 50]  |  2  |  8   | tag 1B + varint 1–2B = 2–3B
+//  vy     | uint32 | [-50, 50]  |  2  |  8   | tag 1B + varint 1–2B = 2–3B
+//  vz     | uint32 | [-50, 50]  |  2  |  8   | tag 1B + varint 1–2B = 2–3B
+//  ---------------------------------------------------------------------------
+//  Step: ≈ 0.003 m/s near zero, ≈ 0.78 m/s near ±50 (vs. 0.392 uniform linear)
+//  Wire: sign in the LSB, so |v| ≲ 12.5 m/s (magnitude code ≤ 63) costs a single
+//        varint byte regardless of direction; only faster axes spill to 2 bytes.
+// ---------------------------------------------------------------------------
+message VelocityState {
+  uint32 vx = 1 [(decentraland.common.quantized_power) = { max: 50.0, pow: 2.0, bits: 8 }];
+  uint32 vy = 2 [(decentraland.common.quantized_power) = { max: 50.0, pow: 2.0, bits: 8 }];
+  uint32 vz = 3 [(decentraland.common.quantized_power) = { max: 50.0, pow: 2.0, bits: 8 }];
+}
+
+// Bitmask values for PlayerInput.buttons.
+enum ButtonFlags {
+  BF_NONE      = 0;
+  BF_JUMP      = 1;   // bit 0
+  BF_SPRINT    = 2;   // bit 1
+  BF_INTERACT  = 4;   // bit 2
+  BF_EMOTE     = 8;   // bit 3
+  BF_CROUCH    = 16;  // bit 4
+  // bits 5-7 reserved
+}
+
+// ---------------------------------------------------------------------------
+// AvatarStateSnapshot — full authoritative state, sent on Channel 0 (reliable)
+// or on resync requests.  Demonstrates wider ranges and mixed encodings.
+//
+//  Field            | Type   | Range            | Q bits | Wire worst-case
+//  -----------------|--------|------------------|--------|-----------------------
+//  x                | uint32 | [-4096, 4096]    |   16   | tag 1B + varint 3B = 4B
+//  y                | uint32 | [-256,   256]    |   14   | tag 1B + varint 2B = 3B
+//  z                | uint32 | [-4096, 4096]    |   16   | tag 1B + varint 3B = 4B
+//  pitch            | uint32 | [-90,    90]     |   10   | tag 1B + varint 2B = 3B
+//  yaw              | uint32 | [-180,  180]     |   12   | tag 1B + varint 2B = 3B
+//  entity_id        | uint32 | [0, 1 048 575]   |   20   | tag 1B + varint 3B = 4B
+//  animation_state  | uint32 | [0,       63]    |    6   | tag 1B + varint 1B = 2B
+//  is_grounded      | bool   | —                |   —    | tag 1B + varint 1B = 2B
+//  timestamp        | double | —                |   —    | tag 1B + fixed64  8B = 9B
+//  ---------------------------------------------------------------------------
+//  Worst-case: 34 B  (vs. 45 B raw: 5×float + 2×uint32 + bool + double)
+//  Step: x/z ≈ 0.125 units; y ≈ 0.031 units; pitch ≈ 0.176°; yaw ≈ 0.088°
+// ---------------------------------------------------------------------------
+message AvatarStateSnapshot {
+  // World-space position.
+  uint32 x               = 1 [(decentraland.common.quantized)  = { min: -4096.0, max: 4096.0, bits: 16 }];
+  uint32 y               = 2 [(decentraland.common.quantized)  = { min:  -256.0, max:  256.0, bits: 14 }];
+  uint32 z               = 3 [(decentraland.common.quantized)  = { min: -4096.0, max: 4096.0, bits: 16 }];
+
+  // View angles.
+  uint32 pitch           = 4 [(decentraland.common.quantized)  = { min:  -90.0,  max:   90.0, bits: 10 }];
+  uint32 yaw             = 5 [(decentraland.common.quantized)  = { min: -180.0,  max:  180.0, bits: 12 }];
+
+  // Identity and animation state.
+  uint32 entity_id       = 6 [(decentraland.common.bit_packed) = { bits: 20 }];
+  uint32 animation_state = 7 [(decentraland.common.bit_packed) = { bits:  6 }];
+
+  // Un-annotated fields — encoded at their natural width.
+  bool   is_grounded     = 8;
+  double timestamp       = 9;   // server epoch milliseconds
+}

package/{kernel/apis/common/UserData.proto → proto/decentraland/common/sdk/user_data.proto}

@@ -1,4 +1,5 @@
 syntax = "proto3";
+package decentraland.common.sdk;
 
 message Snapshots {
     string face256 = 1;

package/proto/decentraland/common/texture.proto

@@ -0,0 +1,45 @@
+syntax = "proto3";
+package decentraland.common;
+import "decentraland/common/vectors.proto";
+
+enum TextureWrapMode {
+  TWM_REPEAT = 0;
+  TWM_CLAMP = 1;
+  TWM_MIRROR = 2;
+}
+
+enum TextureFilterMode {
+  TFM_POINT = 0;
+  TFM_BILINEAR = 1;
+  TFM_TRILINEAR = 2;
+}
+
+message Texture {
+  string src = 1;
+  optional TextureWrapMode wrap_mode = 2; // default = TextureWrapMode.Clamp
+  optional TextureFilterMode filter_mode = 3; // default = FilterMode.Bilinear
+
+  // Final uv = offset + (input_uv * tiling)
+  optional Vector2 offset = 4; // default = Vector2.Zero; Offset for texture positioning, only works for the texture property in PbrMaterial or UnlitMaterial.
+  optional Vector2 tiling = 5; // default = Vector2.One; Tiling multiplier for texture repetition, only works for the texture property in PbrMaterial or UnlitMaterial.
+}
+
+message AvatarTexture {
+  string user_id = 1;
+  optional TextureWrapMode wrap_mode = 2; // default = TextureWrapMode.Clamp
+  optional TextureFilterMode filter_mode = 3; // default = FilterMode.Bilinear
+}
+
+message VideoTexture {
+  uint32 video_player_entity = 1;
+  optional TextureWrapMode wrap_mode = 2; // default = TextureWrapMode.Clamp
+  optional TextureFilterMode filter_mode = 3; // default = FilterMode.Bilinear
+}
+
+message TextureUnion {
+  oneof tex {
+    Texture texture = 1; // default = null
+    AvatarTexture avatar_texture = 2; // default = null
+    VideoTexture video_texture = 3; // default = null
+  }
+}

package/proto/decentraland/common/vectors.proto

@@ -0,0 +1,26 @@
+syntax = "proto3";
+package decentraland.common;
+
+message Position {
+  float x = 1;
+  float y = 2;
+  float z = 3;
+}
+
+message Vector3 {
+  float x = 1;
+  float y = 2;
+  float z = 3;
+}
+
+message Vector2 {
+  float x = 1;
+  float y = 2;
+}
+
+message Quaternion {
+  float x = 1;
+  float y = 2;
+  float z = 3;
+  float w = 4;
+}

package/proto/decentraland/kernel/apis/comms_api.proto

@@ -0,0 +1,61 @@
+syntax = "proto3";
+package decentraland.kernel.apis;
+
+enum VideoTrackSourceType {
+  VTST_UNKNOWN = 0;
+  VTST_CAMERA = 1;
+  VTST_SCREEN_SHARE = 2;
+}
+
+message VideoTracksActiveStreamsRequest {
+}
+
+message VideoTracksActiveStreamsResponse {
+    repeated VideoTracksActiveStreamsData streams = 1;
+}
+
+message VideoTracksActiveStreamsData {
+    string identity = 1;
+    string track_sid = 2;
+    VideoTrackSourceType source_type = 3;
+}
+
+message SubscribeToTopicRequest {
+  string topic = 1;
+}
+
+message SubscribeToTopicResponse {}
+
+message UnsubscribeFromTopicRequest {
+  string topic = 1;
+}
+
+message UnsubscribeFromTopicResponse {}
+
+message PublishDataRequest {
+  string topic = 1;
+  string data = 2;
+}
+
+message PublishDataResponse {}
+
+message ConsumeMessagesRequest {
+  string topic = 1;
+}
+
+message ConsumeMessages {
+  string sender = 1;
+  string data = 2;
+}
+
+message ConsumeMessagesResponse {
+  repeated ConsumeMessages messages = 1;
+}
+
+service CommsApiService {
+  rpc GetActiveVideoStreams(VideoTracksActiveStreamsRequest) returns (VideoTracksActiveStreamsResponse) {}
+  rpc SubscribeToTopic(SubscribeToTopicRequest) returns (SubscribeToTopicResponse) {}
+  rpc UnsubscribeFromTopic(UnsubscribeFromTopicRequest) returns (UnsubscribeFromTopicResponse) {}
+  rpc PublishData(PublishDataRequest) returns (PublishDataResponse) {}
+  rpc ConsumeMessages(ConsumeMessagesRequest) returns (ConsumeMessagesResponse) {}
+}

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

@@ -0,0 +1,29 @@
+syntax = "proto3";
+package decentraland.kernel.apis;
+
+message RealSendRequest {
+  string message = 1;
+}
+
+message RealSendResponse {}
+
+message SendBinaryRequest {
+  repeated bytes data = 1;  // @deprecated old broadcasted messages. Use peerData with an empty array for broadcasting.
+  repeated PeerMessageData peer_data = 2; // peer-to-peer messages
+}
+
+message PeerMessageData {
+  repeated bytes data = 1;
+  repeated string address = 2; // if address is empty, its a broadcast message
+}
+
+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) {}
+  rpc SendBinary(SendBinaryRequest) returns (SendBinaryResponse) {}
+}

package/{kernel/apis/DevTools.proto → proto/decentraland/kernel/apis/dev_tools.proto}

@@ -1,4 +1,5 @@
 syntax = "proto3";
+package decentraland.kernel.apis;
 
 message DevToolsBody {
     string type = 1;
@@ -7,6 +8,8 @@ message DevToolsBody {
 
 message EventResponse {}
 
+// @deprecated
 service DevToolsService {
+    // @deprecated
     rpc Event(DevToolsBody) returns (EventResponse) {}
 }