@dcl/protocol 1.0.0-30361475985.commit-df8a4ff → 1.0.0-30376440685.commit-2726089

package/README.md

@@ -67,3 +67,220 @@ In this case, there is no problem with when each PR is merged. It's recommendabl
 ## Comms
 
 TODO
+
+---
+
+# Bitwise Serialization Plugin (`protoc-gen-bitwise`)
+
+A custom protoc plugin that generates C# partial classes with typed float
+accessors for quantized `uint32` fields in high-frequency MMO networking
+messages (position deltas, player input, etc.).  It runs alongside
+`--csharp_out` in the same protoc invocation; the two output files coexist
+via C# `partial class`.
+
+## How it works
+
+Protobuf encodes `uint32` values as varints, which are already compact for
+small values: a value up to 2¹⁴−1 costs 2 bytes, up to 2²¹−1 costs 3 bytes.
+Rather than a separate binary packing layer, the plugin leverages this:
+
+1. Declare quantized fields as `uint32` in the `.proto` schema and annotate
+   them with `[(decentraland.common.quantized)]` to specify the float range
+   and bit resolution.
+2. `--csharp_out` generates the standard protobuf class with the raw `uint32`
+   property (e.g. `PositionX`).
+3. `--bitwise_out` (this plugin) generates a `partial class` extension with a
+   computed float accessor (e.g. `PositionXQuantized`) that encodes/decodes
+   transparently via `Quantize.Encode` / `Quantize.Decode` on every access —
+   the raw `uint32` property remains the single source of truth (no cache to
+   go stale when the raw field is mutated directly).
+
+The wire representation is a standard protobuf message — any protobuf-capable
+client can read it without knowledge of the plugin.
+
+## Prerequisites
+
+| Requirement | Version |
+|---|---|
+| Node.js | 16+ |
+| `protoc` | 3.19+ |
+
+The plugin is a dependency-free Node script — no `npm install` or extra
+packages are required to run it.
+
+## Step 1 — Annotate your `.proto` file
+
+Declare quantized fields as `uint32` and import `options.proto`:
+
+```protobuf
+syntax = "proto3";
+
+import "decentraland/common/options.proto";
+
+package decentraland.kernel.comms.v3;
+
+message PositionDelta {
+  // Float range [-100, 100] quantized to 16 bits ≈ 0.003-unit precision.
+  // Stored as uint32 on the wire; protobuf encodes it as a 3-byte varint.
+  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 }];
+
+  // Unannotated uint32: protobuf varint encodes small values compactly by default.
+  uint32 entity_id = 4 [(decentraland.common.bit_packed) = { bits: 20 }];
+}
+```
+
+### Annotation reference
+
+| Annotation | Target type | Parameters | Effect |
+|---|---|---|---|
+| `[(decentraland.common.quantized)]` | `uint32` | `min`, `max`, `bits` | Plugin emits a `float {Name}Quantized` accessor and a `{Name}QuantizedStep` const |
+| `[(decentraland.common.quantized_power)]` | `uint32` | `max`, `pow`, `bits` | Power-law quantizer over `[-max, max]`: `(bits-1)`-bit magnitude (high bits) + sign (LSB), decoded as `sign·max·u^pow`. Exact zero; `pow>1` gives fine resolution near zero, coarse near `±max`; sign in the LSB keeps small magnitudes one varint byte. `float {Name}Quantized` accessor (`Quantize.EncodePower`/`DecodePower`) |
+| `[(decentraland.common.bit_packed)]` | `uint32` | `bits` | Documents the value range; protobuf handles varint compaction automatically |
+
+### Wire cost at worst-case (all bits set)
+
+| Quantization bits | Max value | Varint bytes | Tag (field ≤ 15) | Total per field |
+|---|---|---|---|---|
+| 8 | 255 | 2 | 1 | 3 B |
+| 12 | 4 095 | 2 | 1 | 3 B |
+| 14 | 16 383 | 2 | 1 | 3 B |
+| 16 | 65 535 | 3 | 1 | 4 B |
+| 20 | 1 048 575 | 3 | 1 | 4 B |
+
+Proto3 omits fields equal to their default value (0), so average cost is lower.
+
+## Step 2 — Run protoc
+
+```bash
+protoc \
+  --proto_path=proto \
+  --proto_path=/path/to/google/protobuf/include \
+  --csharp_out=generated/cs \
+  --plugin=protoc-gen-bitwise=protoc-gen-bitwise/plugin.js \
+  --bitwise_out=generated/cs \
+  proto/decentraland/kernel/comms/v3/comms.proto
+```
+
+> `plugin.js` carries a `#!/usr/bin/env node` shebang. On Windows, protoc
+> cannot exec a `.js` directly, so point `--plugin` at a small `.cmd` wrapper
+> that runs `node plugin.js`; on unix an equivalent shell script is used. Both
+> consumer repos (Pulse, unity-explorer) generate this wrapper automatically.
+
+The plugin emits one `*.Bitwise.cs` file (PascalCase, flat in the output
+directory) for each `.proto` file that contains at least one `[(quantized)]`
+field.
+
+## Step 3 — Copy the runtime
+
+Copy `Quantize.cs` into your project:
+
+```
+Assets/
+└── Scripts/
+    └── Networking/
+        └── Bitwise/
+            └── Quantize.cs   ← protoc-gen-bitwise/runtime/cs/Quantize.cs
+```
+
+`Quantize.cs` lives in the `Decentraland.Networking.Bitwise` namespace and
+provides the static encode/decode methods used by the generated accessors:
+
+```csharp
+public static class Quantize
+{
+    public static uint  Encode(float value, float min, float max, int bits);
+    public static float Decode(uint encoded, float min, float max, int bits);
+    public static uint  EncodePower(float value, float max, float pow, int bits);
+    public static float DecodePower(uint encoded, float max, float pow, int bits);
+}
+```
+
+## Step 4 — Use the generated code
+
+The plugin emits a `partial class` that adds float accessors on top of the
+standard protobuf-generated `uint32` properties:
+
+```csharp
+using Decentraland.Kernel.Comms.V3;
+
+// --- Build and send ---
+var delta = new PositionDelta();
+delta.DxQuantized = 3.14f;   // encodes to uint32, stored in delta.Dx
+delta.DyQuantized = 0f;
+delta.DzQuantized = -7.5f;
+delta.EntityId    = 42u;
+
+byte[] bytes = delta.ToByteArray();   // standard protobuf serialization
+SendOnChannel1(bytes);
+
+// --- Receive and read ---
+var received = PositionDelta.Parser.ParseFrom(receivedBytes);
+if (!received.AreQuantizedFieldsInRange()) return;   // reject malformed/hostile codes
+float x = received.DxQuantized;   // decoded from the stored uint32 on each access
+float y = received.DyQuantized;
+float z = received.DzQuantized;
+```
+
+## Generated file example
+
+For the `comms.proto` file above the plugin emits `Comms.Bitwise.cs` (one file
+per `.proto`, named after the proto file). Each quantized field gets a
+`{Name}QuantizedStep` const and a float accessor; each message gets an
+`AreQuantizedFieldsInRange()` guard for validating inbound wire codes:
+
+```csharp
+// <auto-generated>
+//   Generated by protoc-gen-bitwise. DO NOT EDIT.
+//   Source: decentraland/kernel/comms/v3/comms.proto
+// </auto-generated>
+
+using Decentraland.Networking.Bitwise;
+
+namespace Decentraland.Kernel.Comms.V3
+{
+    public partial class PositionDelta
+    {
+        /// <summary>Coarsest quantization step of <see cref="DxQuantized"/>. Safe as an equality tolerance.</summary>
+        public const float DxQuantizedStep = 0.0030518044f;
+        /// <summary>Float accessor for <see cref="Dx"/>. Range [-100.0f, 100.0f], 16 bits, step ≈ 0.0030518.</summary>
+        public float DxQuantized
+        {
+            get => Quantize.Decode(Dx, -100.0f, 100.0f, 16);
+            set => Dx = Quantize.Encode(value, -100.0f, 100.0f, 16);
+        }
+
+        /// <summary>Coarsest quantization step of <see cref="DyQuantized"/>. Safe as an equality tolerance.</summary>
+        public const float DyQuantizedStep = 0.0030518044f;
+        /// <summary>Float accessor for <see cref="Dy"/>. Range [-100.0f, 100.0f], 16 bits, step ≈ 0.0030518.</summary>
+        public float DyQuantized
+        {
+            get => Quantize.Decode(Dy, -100.0f, 100.0f, 16);
+            set => Dy = Quantize.Encode(value, -100.0f, 100.0f, 16);
+        }
+
+        /// <summary>Coarsest quantization step of <see cref="DzQuantized"/>. Safe as an equality tolerance.</summary>
+        public const float DzQuantizedStep = 0.0030518044f;
+        /// <summary>Float accessor for <see cref="Dz"/>. Range [-100.0f, 100.0f], 16 bits, step ≈ 0.0030518.</summary>
+        public float DzQuantized
+        {
+            get => Quantize.Decode(Dz, -100.0f, 100.0f, 16);
+            set => Dz = Quantize.Encode(value, -100.0f, 100.0f, 16);
+        }
+
+        /// <summary>
+        ///     True when every quantized field holds a wire code within its declared bit width
+        ///     (<c>0 .. 2^bits-1</c>). The encoder never emits a code above this bound, so a larger
+        ///     value is a malformed/hostile message: decoding it would land far outside the field's
+        ///     <c>[min, max]</c> and, since the server relays raw codes verbatim, poison every observer.
+        ///     Reject before storing or relaying. Pure integer comparison — no decode.
+        /// </summary>
+        public bool AreQuantizedFieldsInRange() =>
+            Dx <= 65535u
+            && Dy <= 65535u
+            && Dz <= 65535u;
+    }
+
+} // namespace Decentraland.Kernel.Comms.V3
+```

package/out-js/decentraland/kernel/apis/restricted_actions.gen.d.ts

@@ -2,6 +2,38 @@ import _m0 from "protobufjs/minimal";
 import { Vector2, Vector3 } from "../../common/vectors.gen";
 import { AvatarMask } from "../../sdk/components/common/avatar_mask.gen";
 export declare const protobufPackage = "decentraland.kernel.apis";
+/**
+ * Identifies which fullscreen explorer panel OpenExplorerUi targets.
+ * EU_SETTINGS holds 0 so an unset `ui` field defaults to the least-intrusive panel.
+ */
+export declare enum ExplorerUi {
+    EU_SETTINGS = 0,
+    EU_MAP = 1,
+    EU_BACKPACK = 2,
+    EU_CAMERA_REEL = 3,
+    EU_COMMUNITIES = 4,
+    EU_PLACES = 5,
+    EU_EVENTS = 6,
+    UNRECOGNIZED = -1
+}
+export declare function explorerUiFromJSON(object: any): ExplorerUi;
+export declare function explorerUiToJSON(object: ExplorerUi): string;
+/** Verdict of an OpenExplorerUi request (enum rather than a bool so new outcomes stay expressible). */
+export declare enum OpenExplorerUiResult {
+    UNSPECIFIED = 0,
+    OPENED = 1,
+    /** WAS_ALREADY_OPEN - a fullscreen panel is already open */
+    WAS_ALREADY_OPEN = 2,
+    /** REJECTED_NOT_CURRENT_SCENE - the standard restricted-actions current-scene gate rejected the call */
+    REJECTED_NOT_CURRENT_SCENE = 3,
+    /** REJECTED_FEATURE_DISABLED - the requested section is hidden by feature flags or client doesn't have that feature */
+    REJECTED_FEATURE_DISABLED = 4,
+    /** REJECTED_NO_USER_GESTURE - rejected: the call did not originate from a user gesture */
+    REJECTED_NO_USER_GESTURE = 5,
+    UNRECOGNIZED = -1
+}
+export declare function openExplorerUiResultFromJSON(object: any): OpenExplorerUiResult;
+export declare function openExplorerUiResultToJSON(object: OpenExplorerUiResult): string;
 export interface MovePlayerToRequest {
     newRelativePosition: Vector3 | undefined;
     cameraTarget?: Vector3 | undefined;
@@ -53,6 +85,13 @@ export interface EmptyResponse {
 }
 export interface StopEmoteRequest {
 }
+export interface OpenExplorerUiRequest {
+    ui: ExplorerUi;
+}
+export interface OpenExplorerUiResponse {
+    /** Carries only the verdict of the open action. */
+    openResult: OpenExplorerUiResult;
+}
 export declare namespace MovePlayerToRequest {
     function encode(message: MovePlayerToRequest, writer?: _m0.Writer): _m0.Writer;
     function decode(input: _m0.Reader | Uint8Array, length?: number): MovePlayerToRequest;
@@ -181,6 +220,22 @@ export declare namespace StopEmoteRequest {
     function create<I extends Exact<DeepPartial<StopEmoteRequest>, I>>(base?: I): StopEmoteRequest;
     function fromPartial<I extends Exact<DeepPartial<StopEmoteRequest>, I>>(_: I): StopEmoteRequest;
 }
+export declare namespace OpenExplorerUiRequest {
+    function encode(message: OpenExplorerUiRequest, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): OpenExplorerUiRequest;
+    function fromJSON(object: any): OpenExplorerUiRequest;
+    function toJSON(message: OpenExplorerUiRequest): unknown;
+    function create<I extends Exact<DeepPartial<OpenExplorerUiRequest>, I>>(base?: I): OpenExplorerUiRequest;
+    function fromPartial<I extends Exact<DeepPartial<OpenExplorerUiRequest>, I>>(object: I): OpenExplorerUiRequest;
+}
+export declare namespace OpenExplorerUiResponse {
+    function encode(message: OpenExplorerUiResponse, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): OpenExplorerUiResponse;
+    function fromJSON(object: any): OpenExplorerUiResponse;
+    function toJSON(message: OpenExplorerUiResponse): unknown;
+    function create<I extends Exact<DeepPartial<OpenExplorerUiResponse>, I>>(base?: I): OpenExplorerUiResponse;
+    function fromPartial<I extends Exact<DeepPartial<OpenExplorerUiResponse>, I>>(object: I): OpenExplorerUiResponse;
+}
 export type RestrictedActionsServiceDefinition = typeof RestrictedActionsServiceDefinition;
 export declare const RestrictedActionsServiceDefinition: {
     readonly name: "RestrictedActionsService";
@@ -283,6 +338,15 @@ export declare const RestrictedActionsServiceDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        /** OpenExplorerUi opens a specific fullscreen explorer panel and returns the open verdict. */
+        readonly openExplorerUi: {
+            readonly name: "OpenExplorerUi";
+            readonly requestType: typeof OpenExplorerUiRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof OpenExplorerUiResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

package/out-js/decentraland/kernel/apis/restricted_actions.gen.js

@@ -3,12 +3,141 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestrictedActionsServiceDefinition = exports.StopEmoteRequest = exports.EmptyResponse = exports.CopyToClipboardRequest = exports.TeleportToResponse = exports.MovePlayerToResponse = exports.TriggerEmoteResponse = exports.SuccessResponse = exports.TriggerSceneEmoteRequest = exports.CommsAdapterRequest = exports.UnblockPointerRequest = exports.OpenNftDialogRequest = exports.OpenExternalUrlRequest = exports.ChangeRealmRequest = exports.TriggerEmoteRequest = exports.TeleportToRequest = exports.MovePlayerToRequest = exports.protobufPackage = void 0;
+exports.RestrictedActionsServiceDefinition = exports.OpenExplorerUiResponse = exports.OpenExplorerUiRequest = exports.StopEmoteRequest = exports.EmptyResponse = exports.CopyToClipboardRequest = exports.TeleportToResponse = exports.MovePlayerToResponse = exports.TriggerEmoteResponse = exports.SuccessResponse = exports.TriggerSceneEmoteRequest = exports.CommsAdapterRequest = exports.UnblockPointerRequest = exports.OpenNftDialogRequest = exports.OpenExternalUrlRequest = exports.ChangeRealmRequest = exports.TriggerEmoteRequest = exports.TeleportToRequest = exports.MovePlayerToRequest = exports.OpenExplorerUiResult = exports.ExplorerUi = exports.protobufPackage = void 0;
+exports.explorerUiFromJSON = explorerUiFromJSON;
+exports.explorerUiToJSON = explorerUiToJSON;
+exports.openExplorerUiResultFromJSON = openExplorerUiResultFromJSON;
+exports.openExplorerUiResultToJSON = openExplorerUiResultToJSON;
 /* eslint-disable */
 const minimal_1 = __importDefault(require("protobufjs/minimal"));
 const vectors_gen_1 = require("../../common/vectors.gen");
 const avatar_mask_gen_1 = require("../../sdk/components/common/avatar_mask.gen");
 exports.protobufPackage = "decentraland.kernel.apis";
+/**
+ * Identifies which fullscreen explorer panel OpenExplorerUi targets.
+ * EU_SETTINGS holds 0 so an unset `ui` field defaults to the least-intrusive panel.
+ */
+var ExplorerUi;
+(function (ExplorerUi) {
+    ExplorerUi[ExplorerUi["EU_SETTINGS"] = 0] = "EU_SETTINGS";
+    ExplorerUi[ExplorerUi["EU_MAP"] = 1] = "EU_MAP";
+    ExplorerUi[ExplorerUi["EU_BACKPACK"] = 2] = "EU_BACKPACK";
+    ExplorerUi[ExplorerUi["EU_CAMERA_REEL"] = 3] = "EU_CAMERA_REEL";
+    ExplorerUi[ExplorerUi["EU_COMMUNITIES"] = 4] = "EU_COMMUNITIES";
+    ExplorerUi[ExplorerUi["EU_PLACES"] = 5] = "EU_PLACES";
+    ExplorerUi[ExplorerUi["EU_EVENTS"] = 6] = "EU_EVENTS";
+    ExplorerUi[ExplorerUi["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ExplorerUi || (exports.ExplorerUi = ExplorerUi = {}));
+function explorerUiFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "EU_SETTINGS":
+            return ExplorerUi.EU_SETTINGS;
+        case 1:
+        case "EU_MAP":
+            return ExplorerUi.EU_MAP;
+        case 2:
+        case "EU_BACKPACK":
+            return ExplorerUi.EU_BACKPACK;
+        case 3:
+        case "EU_CAMERA_REEL":
+            return ExplorerUi.EU_CAMERA_REEL;
+        case 4:
+        case "EU_COMMUNITIES":
+            return ExplorerUi.EU_COMMUNITIES;
+        case 5:
+        case "EU_PLACES":
+            return ExplorerUi.EU_PLACES;
+        case 6:
+        case "EU_EVENTS":
+            return ExplorerUi.EU_EVENTS;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ExplorerUi.UNRECOGNIZED;
+    }
+}
+function explorerUiToJSON(object) {
+    switch (object) {
+        case ExplorerUi.EU_SETTINGS:
+            return "EU_SETTINGS";
+        case ExplorerUi.EU_MAP:
+            return "EU_MAP";
+        case ExplorerUi.EU_BACKPACK:
+            return "EU_BACKPACK";
+        case ExplorerUi.EU_CAMERA_REEL:
+            return "EU_CAMERA_REEL";
+        case ExplorerUi.EU_COMMUNITIES:
+            return "EU_COMMUNITIES";
+        case ExplorerUi.EU_PLACES:
+            return "EU_PLACES";
+        case ExplorerUi.EU_EVENTS:
+            return "EU_EVENTS";
+        case ExplorerUi.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** Verdict of an OpenExplorerUi request (enum rather than a bool so new outcomes stay expressible). */
+var OpenExplorerUiResult;
+(function (OpenExplorerUiResult) {
+    OpenExplorerUiResult[OpenExplorerUiResult["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    OpenExplorerUiResult[OpenExplorerUiResult["OPENED"] = 1] = "OPENED";
+    /** WAS_ALREADY_OPEN - a fullscreen panel is already open */
+    OpenExplorerUiResult[OpenExplorerUiResult["WAS_ALREADY_OPEN"] = 2] = "WAS_ALREADY_OPEN";
+    /** REJECTED_NOT_CURRENT_SCENE - the standard restricted-actions current-scene gate rejected the call */
+    OpenExplorerUiResult[OpenExplorerUiResult["REJECTED_NOT_CURRENT_SCENE"] = 3] = "REJECTED_NOT_CURRENT_SCENE";
+    /** REJECTED_FEATURE_DISABLED - the requested section is hidden by feature flags or client doesn't have that feature */
+    OpenExplorerUiResult[OpenExplorerUiResult["REJECTED_FEATURE_DISABLED"] = 4] = "REJECTED_FEATURE_DISABLED";
+    /** REJECTED_NO_USER_GESTURE - rejected: the call did not originate from a user gesture */
+    OpenExplorerUiResult[OpenExplorerUiResult["REJECTED_NO_USER_GESTURE"] = 5] = "REJECTED_NO_USER_GESTURE";
+    OpenExplorerUiResult[OpenExplorerUiResult["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OpenExplorerUiResult || (exports.OpenExplorerUiResult = OpenExplorerUiResult = {}));
+function openExplorerUiResultFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "UNSPECIFIED":
+            return OpenExplorerUiResult.UNSPECIFIED;
+        case 1:
+        case "OPENED":
+            return OpenExplorerUiResult.OPENED;
+        case 2:
+        case "WAS_ALREADY_OPEN":
+            return OpenExplorerUiResult.WAS_ALREADY_OPEN;
+        case 3:
+        case "REJECTED_NOT_CURRENT_SCENE":
+            return OpenExplorerUiResult.REJECTED_NOT_CURRENT_SCENE;
+        case 4:
+        case "REJECTED_FEATURE_DISABLED":
+            return OpenExplorerUiResult.REJECTED_FEATURE_DISABLED;
+        case 5:
+        case "REJECTED_NO_USER_GESTURE":
+            return OpenExplorerUiResult.REJECTED_NO_USER_GESTURE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OpenExplorerUiResult.UNRECOGNIZED;
+    }
+}
+function openExplorerUiResultToJSON(object) {
+    switch (object) {
+        case OpenExplorerUiResult.UNSPECIFIED:
+            return "UNSPECIFIED";
+        case OpenExplorerUiResult.OPENED:
+            return "OPENED";
+        case OpenExplorerUiResult.WAS_ALREADY_OPEN:
+            return "WAS_ALREADY_OPEN";
+        case OpenExplorerUiResult.REJECTED_NOT_CURRENT_SCENE:
+            return "REJECTED_NOT_CURRENT_SCENE";
+        case OpenExplorerUiResult.REJECTED_FEATURE_DISABLED:
+            return "REJECTED_FEATURE_DISABLED";
+        case OpenExplorerUiResult.REJECTED_NO_USER_GESTURE:
+            return "REJECTED_NO_USER_GESTURE";
+        case OpenExplorerUiResult.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
 function createBaseMovePlayerToRequest() {
     return { newRelativePosition: undefined, cameraTarget: undefined, avatarTarget: undefined, duration: undefined };
 }
@@ -948,6 +1077,118 @@ var StopEmoteRequest;
     }
     StopEmoteRequest.fromPartial = fromPartial;
 })(StopEmoteRequest || (exports.StopEmoteRequest = StopEmoteRequest = {}));
+function createBaseOpenExplorerUiRequest() {
+    return { ui: 0 };
+}
+var OpenExplorerUiRequest;
+(function (OpenExplorerUiRequest) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.ui !== 0) {
+            writer.uint32(8).int32(message.ui);
+        }
+        return writer;
+    }
+    OpenExplorerUiRequest.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOpenExplorerUiRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.ui = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    OpenExplorerUiRequest.decode = decode;
+    function fromJSON(object) {
+        return { ui: isSet(object.ui) ? explorerUiFromJSON(object.ui) : 0 };
+    }
+    OpenExplorerUiRequest.fromJSON = fromJSON;
+    function toJSON(message) {
+        const obj = {};
+        message.ui !== undefined && (obj.ui = explorerUiToJSON(message.ui));
+        return obj;
+    }
+    OpenExplorerUiRequest.toJSON = toJSON;
+    function create(base) {
+        return OpenExplorerUiRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    }
+    OpenExplorerUiRequest.create = create;
+    function fromPartial(object) {
+        var _a;
+        const message = createBaseOpenExplorerUiRequest();
+        message.ui = (_a = object.ui) !== null && _a !== void 0 ? _a : 0;
+        return message;
+    }
+    OpenExplorerUiRequest.fromPartial = fromPartial;
+})(OpenExplorerUiRequest || (exports.OpenExplorerUiRequest = OpenExplorerUiRequest = {}));
+function createBaseOpenExplorerUiResponse() {
+    return { openResult: 0 };
+}
+var OpenExplorerUiResponse;
+(function (OpenExplorerUiResponse) {
+    function encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.openResult !== 0) {
+            writer.uint32(8).int32(message.openResult);
+        }
+        return writer;
+    }
+    OpenExplorerUiResponse.encode = encode;
+    function decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOpenExplorerUiResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.openResult = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    OpenExplorerUiResponse.decode = decode;
+    function fromJSON(object) {
+        return { openResult: isSet(object.openResult) ? openExplorerUiResultFromJSON(object.openResult) : 0 };
+    }
+    OpenExplorerUiResponse.fromJSON = fromJSON;
+    function toJSON(message) {
+        const obj = {};
+        message.openResult !== undefined && (obj.openResult = openExplorerUiResultToJSON(message.openResult));
+        return obj;
+    }
+    OpenExplorerUiResponse.toJSON = toJSON;
+    function create(base) {
+        return OpenExplorerUiResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    }
+    OpenExplorerUiResponse.create = create;
+    function fromPartial(object) {
+        var _a;
+        const message = createBaseOpenExplorerUiResponse();
+        message.openResult = (_a = object.openResult) !== null && _a !== void 0 ? _a : 0;
+        return message;
+    }
+    OpenExplorerUiResponse.fromPartial = fromPartial;
+})(OpenExplorerUiResponse || (exports.OpenExplorerUiResponse = OpenExplorerUiResponse = {}));
 exports.RestrictedActionsServiceDefinition = {
     name: "RestrictedActionsService",
     fullName: "decentraland.kernel.apis.RestrictedActionsService",
@@ -1049,6 +1290,15 @@ exports.RestrictedActionsServiceDefinition = {
             responseStream: false,
             options: {},
         },
+        /** OpenExplorerUi opens a specific fullscreen explorer panel and returns the open verdict. */
+        openExplorerUi: {
+            name: "OpenExplorerUi",
+            requestType: OpenExplorerUiRequest,
+            requestStream: false,
+            responseType: OpenExplorerUiResponse,
+            responseStream: false,
+            options: {},
+        },
     },
 };
 function isSet(value) {