@dcl/protocol 1.0.0-10043247792.commit-428d1eb

package/out-ts/decentraland/kernel/comms/rfc5/ws_comms.gen.ts

@@ -0,0 +1,1029 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.kernel.comms.rfc5";
+
+/** Sent to the clients when the challenge is validated and they are authenticated. */
+export interface WsWelcome {
+  alias: number;
+  peerIdentities: { [key: number]: string };
+}
+
+export interface WsWelcome_PeerIdentitiesEntry {
+  key: number;
+  value: string;
+}
+
+/** Sent to the clients when a user connects and their identity is authenticated. */
+export interface WsPeerJoin {
+  alias: number;
+  address: string;
+}
+
+/** Sent to the clients when a user gets disconnected. */
+export interface WsPeerLeave {
+  alias: number;
+}
+
+/** This is the data package for all user messages. */
+export interface WsPeerUpdate {
+  fromAlias: number;
+  body: Uint8Array;
+  unreliable: boolean;
+}
+
+/**
+ * Sent to the clients as first message, it contains a challenge string and a
+ * hint about if the same address is connected to another room. In such case,
+ * after authentication, the server may decide to end the former connection. This
+ * hint exists for UX purposes of the explorers for cases like multiple running
+ * instances of the explorer.
+ */
+export interface WsChallengeRequired {
+  challengeToSign: string;
+  alreadyConnected: boolean;
+}
+
+/** Response to WsChallengeRequired, signed using the AuthChain mechanism. */
+export interface WsSignedChallenge {
+  authChainJson: string;
+}
+
+/**
+ * This is the first message sent by the clients, it us used to identify the client
+ * in the server.
+ */
+export interface WsIdentification {
+  address: string;
+}
+
+/**
+ * This message is received by the peers when the same address logs in in a
+ * different session. It should signal that the client should be shut down and not
+ * retry any new comms connection. It can also be used to reject new users joining when
+ * the room capacity has been reached.
+ */
+export interface WsKicked {
+  reason: string;
+}
+
+export interface WsPacket {
+  message?:
+    | { $case: "welcomeMessage"; welcomeMessage: WsWelcome }
+    | { $case: "peerJoinMessage"; peerJoinMessage: WsPeerJoin }
+    | { $case: "peerUpdateMessage"; peerUpdateMessage: WsPeerUpdate }
+    | { $case: "challengeMessage"; challengeMessage: WsChallengeRequired }
+    | { $case: "signedChallengeForServer"; signedChallengeForServer: WsSignedChallenge }
+    | { $case: "peerLeaveMessage"; peerLeaveMessage: WsPeerLeave }
+    | { $case: "peerIdentification"; peerIdentification: WsIdentification }
+    | { $case: "peerKicked"; peerKicked: WsKicked }
+    | undefined;
+}
+
+function createBaseWsWelcome(): WsWelcome {
+  return { alias: 0, peerIdentities: {} };
+}
+
+export namespace WsWelcome {
+  export function encode(message: WsWelcome, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.alias !== 0) {
+      writer.uint32(8).uint32(message.alias);
+    }
+    Object.entries(message.peerIdentities).forEach(([key, value]) => {
+      WsWelcome_PeerIdentitiesEntry.encode({ key: key as any, value }, writer.uint32(18).fork()).ldelim();
+    });
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsWelcome {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsWelcome();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.alias = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          const entry2 = WsWelcome_PeerIdentitiesEntry.decode(reader, reader.uint32());
+          if (entry2.value !== undefined) {
+            message.peerIdentities[entry2.key] = entry2.value;
+          }
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsWelcome {
+    return {
+      alias: isSet(object.alias) ? Number(object.alias) : 0,
+      peerIdentities: isObject(object.peerIdentities)
+        ? Object.entries(object.peerIdentities).reduce<{ [key: number]: string }>((acc, [key, value]) => {
+          acc[Number(key)] = String(value);
+          return acc;
+        }, {})
+        : {},
+    };
+  }
+
+  export function toJSON(message: WsWelcome): unknown {
+    const obj: any = {};
+    message.alias !== undefined && (obj.alias = Math.round(message.alias));
+    obj.peerIdentities = {};
+    if (message.peerIdentities) {
+      Object.entries(message.peerIdentities).forEach(([k, v]) => {
+        obj.peerIdentities[k] = v;
+      });
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsWelcome>, I>>(base?: I): WsWelcome {
+    return WsWelcome.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsWelcome>, I>>(object: I): WsWelcome {
+    const message = createBaseWsWelcome();
+    message.alias = object.alias ?? 0;
+    message.peerIdentities = Object.entries(object.peerIdentities ?? {}).reduce<{ [key: number]: string }>(
+      (acc, [key, value]) => {
+        if (value !== undefined) {
+          acc[Number(key)] = String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  }
+}
+
+function createBaseWsWelcome_PeerIdentitiesEntry(): WsWelcome_PeerIdentitiesEntry {
+  return { key: 0, value: "" };
+}
+
+export namespace WsWelcome_PeerIdentitiesEntry {
+  export function encode(message: WsWelcome_PeerIdentitiesEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key !== 0) {
+      writer.uint32(8).uint32(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsWelcome_PeerIdentitiesEntry {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsWelcome_PeerIdentitiesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.key = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsWelcome_PeerIdentitiesEntry {
+    return { key: isSet(object.key) ? Number(object.key) : 0, value: isSet(object.value) ? String(object.value) : "" };
+  }
+
+  export function toJSON(message: WsWelcome_PeerIdentitiesEntry): unknown {
+    const obj: any = {};
+    message.key !== undefined && (obj.key = Math.round(message.key));
+    message.value !== undefined && (obj.value = message.value);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsWelcome_PeerIdentitiesEntry>, I>>(
+    base?: I,
+  ): WsWelcome_PeerIdentitiesEntry {
+    return WsWelcome_PeerIdentitiesEntry.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsWelcome_PeerIdentitiesEntry>, I>>(
+    object: I,
+  ): WsWelcome_PeerIdentitiesEntry {
+    const message = createBaseWsWelcome_PeerIdentitiesEntry();
+    message.key = object.key ?? 0;
+    message.value = object.value ?? "";
+    return message;
+  }
+}
+
+function createBaseWsPeerJoin(): WsPeerJoin {
+  return { alias: 0, address: "" };
+}
+
+export namespace WsPeerJoin {
+  export function encode(message: WsPeerJoin, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.alias !== 0) {
+      writer.uint32(8).uint32(message.alias);
+    }
+    if (message.address !== "") {
+      writer.uint32(18).string(message.address);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerJoin {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsPeerJoin();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.alias = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsPeerJoin {
+    return {
+      alias: isSet(object.alias) ? Number(object.alias) : 0,
+      address: isSet(object.address) ? String(object.address) : "",
+    };
+  }
+
+  export function toJSON(message: WsPeerJoin): unknown {
+    const obj: any = {};
+    message.alias !== undefined && (obj.alias = Math.round(message.alias));
+    message.address !== undefined && (obj.address = message.address);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsPeerJoin>, I>>(base?: I): WsPeerJoin {
+    return WsPeerJoin.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsPeerJoin>, I>>(object: I): WsPeerJoin {
+    const message = createBaseWsPeerJoin();
+    message.alias = object.alias ?? 0;
+    message.address = object.address ?? "";
+    return message;
+  }
+}
+
+function createBaseWsPeerLeave(): WsPeerLeave {
+  return { alias: 0 };
+}
+
+export namespace WsPeerLeave {
+  export function encode(message: WsPeerLeave, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.alias !== 0) {
+      writer.uint32(8).uint32(message.alias);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerLeave {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsPeerLeave();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.alias = reader.uint32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsPeerLeave {
+    return { alias: isSet(object.alias) ? Number(object.alias) : 0 };
+  }
+
+  export function toJSON(message: WsPeerLeave): unknown {
+    const obj: any = {};
+    message.alias !== undefined && (obj.alias = Math.round(message.alias));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsPeerLeave>, I>>(base?: I): WsPeerLeave {
+    return WsPeerLeave.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsPeerLeave>, I>>(object: I): WsPeerLeave {
+    const message = createBaseWsPeerLeave();
+    message.alias = object.alias ?? 0;
+    return message;
+  }
+}
+
+function createBaseWsPeerUpdate(): WsPeerUpdate {
+  return { fromAlias: 0, body: new Uint8Array(0), unreliable: false };
+}
+
+export namespace WsPeerUpdate {
+  export function encode(message: WsPeerUpdate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.fromAlias !== 0) {
+      writer.uint32(8).uint32(message.fromAlias);
+    }
+    if (message.body.length !== 0) {
+      writer.uint32(18).bytes(message.body);
+    }
+    if (message.unreliable === true) {
+      writer.uint32(24).bool(message.unreliable);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPeerUpdate {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsPeerUpdate();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.fromAlias = reader.uint32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.body = reader.bytes();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.unreliable = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsPeerUpdate {
+    return {
+      fromAlias: isSet(object.fromAlias) ? Number(object.fromAlias) : 0,
+      body: isSet(object.body) ? bytesFromBase64(object.body) : new Uint8Array(0),
+      unreliable: isSet(object.unreliable) ? Boolean(object.unreliable) : false,
+    };
+  }
+
+  export function toJSON(message: WsPeerUpdate): unknown {
+    const obj: any = {};
+    message.fromAlias !== undefined && (obj.fromAlias = Math.round(message.fromAlias));
+    message.body !== undefined &&
+      (obj.body = base64FromBytes(message.body !== undefined ? message.body : new Uint8Array(0)));
+    message.unreliable !== undefined && (obj.unreliable = message.unreliable);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsPeerUpdate>, I>>(base?: I): WsPeerUpdate {
+    return WsPeerUpdate.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsPeerUpdate>, I>>(object: I): WsPeerUpdate {
+    const message = createBaseWsPeerUpdate();
+    message.fromAlias = object.fromAlias ?? 0;
+    message.body = object.body ?? new Uint8Array(0);
+    message.unreliable = object.unreliable ?? false;
+    return message;
+  }
+}
+
+function createBaseWsChallengeRequired(): WsChallengeRequired {
+  return { challengeToSign: "", alreadyConnected: false };
+}
+
+export namespace WsChallengeRequired {
+  export function encode(message: WsChallengeRequired, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.challengeToSign !== "") {
+      writer.uint32(10).string(message.challengeToSign);
+    }
+    if (message.alreadyConnected === true) {
+      writer.uint32(16).bool(message.alreadyConnected);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsChallengeRequired {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsChallengeRequired();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.challengeToSign = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.alreadyConnected = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsChallengeRequired {
+    return {
+      challengeToSign: isSet(object.challengeToSign) ? String(object.challengeToSign) : "",
+      alreadyConnected: isSet(object.alreadyConnected) ? Boolean(object.alreadyConnected) : false,
+    };
+  }
+
+  export function toJSON(message: WsChallengeRequired): unknown {
+    const obj: any = {};
+    message.challengeToSign !== undefined && (obj.challengeToSign = message.challengeToSign);
+    message.alreadyConnected !== undefined && (obj.alreadyConnected = message.alreadyConnected);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsChallengeRequired>, I>>(base?: I): WsChallengeRequired {
+    return WsChallengeRequired.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsChallengeRequired>, I>>(object: I): WsChallengeRequired {
+    const message = createBaseWsChallengeRequired();
+    message.challengeToSign = object.challengeToSign ?? "";
+    message.alreadyConnected = object.alreadyConnected ?? false;
+    return message;
+  }
+}
+
+function createBaseWsSignedChallenge(): WsSignedChallenge {
+  return { authChainJson: "" };
+}
+
+export namespace WsSignedChallenge {
+  export function encode(message: WsSignedChallenge, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authChainJson !== "") {
+      writer.uint32(10).string(message.authChainJson);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsSignedChallenge {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsSignedChallenge();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.authChainJson = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsSignedChallenge {
+    return { authChainJson: isSet(object.authChainJson) ? String(object.authChainJson) : "" };
+  }
+
+  export function toJSON(message: WsSignedChallenge): unknown {
+    const obj: any = {};
+    message.authChainJson !== undefined && (obj.authChainJson = message.authChainJson);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsSignedChallenge>, I>>(base?: I): WsSignedChallenge {
+    return WsSignedChallenge.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsSignedChallenge>, I>>(object: I): WsSignedChallenge {
+    const message = createBaseWsSignedChallenge();
+    message.authChainJson = object.authChainJson ?? "";
+    return message;
+  }
+}
+
+function createBaseWsIdentification(): WsIdentification {
+  return { address: "" };
+}
+
+export namespace WsIdentification {
+  export function encode(message: WsIdentification, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsIdentification {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsIdentification();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.address = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsIdentification {
+    return { address: isSet(object.address) ? String(object.address) : "" };
+  }
+
+  export function toJSON(message: WsIdentification): unknown {
+    const obj: any = {};
+    message.address !== undefined && (obj.address = message.address);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsIdentification>, I>>(base?: I): WsIdentification {
+    return WsIdentification.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsIdentification>, I>>(object: I): WsIdentification {
+    const message = createBaseWsIdentification();
+    message.address = object.address ?? "";
+    return message;
+  }
+}
+
+function createBaseWsKicked(): WsKicked {
+  return { reason: "" };
+}
+
+export namespace WsKicked {
+  export function encode(message: WsKicked, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.reason !== "") {
+      writer.uint32(10).string(message.reason);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsKicked {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsKicked();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.reason = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsKicked {
+    return { reason: isSet(object.reason) ? String(object.reason) : "" };
+  }
+
+  export function toJSON(message: WsKicked): unknown {
+    const obj: any = {};
+    message.reason !== undefined && (obj.reason = message.reason);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsKicked>, I>>(base?: I): WsKicked {
+    return WsKicked.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsKicked>, I>>(object: I): WsKicked {
+    const message = createBaseWsKicked();
+    message.reason = object.reason ?? "";
+    return message;
+  }
+}
+
+function createBaseWsPacket(): WsPacket {
+  return { message: undefined };
+}
+
+export namespace WsPacket {
+  export function encode(message: WsPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.message?.$case) {
+      case "welcomeMessage":
+        WsWelcome.encode(message.message.welcomeMessage, writer.uint32(10).fork()).ldelim();
+        break;
+      case "peerJoinMessage":
+        WsPeerJoin.encode(message.message.peerJoinMessage, writer.uint32(18).fork()).ldelim();
+        break;
+      case "peerUpdateMessage":
+        WsPeerUpdate.encode(message.message.peerUpdateMessage, writer.uint32(26).fork()).ldelim();
+        break;
+      case "challengeMessage":
+        WsChallengeRequired.encode(message.message.challengeMessage, writer.uint32(34).fork()).ldelim();
+        break;
+      case "signedChallengeForServer":
+        WsSignedChallenge.encode(message.message.signedChallengeForServer, writer.uint32(42).fork()).ldelim();
+        break;
+      case "peerLeaveMessage":
+        WsPeerLeave.encode(message.message.peerLeaveMessage, writer.uint32(50).fork()).ldelim();
+        break;
+      case "peerIdentification":
+        WsIdentification.encode(message.message.peerIdentification, writer.uint32(58).fork()).ldelim();
+        break;
+      case "peerKicked":
+        WsKicked.encode(message.message.peerKicked, writer.uint32(66).fork()).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WsPacket {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWsPacket();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = { $case: "welcomeMessage", welcomeMessage: WsWelcome.decode(reader, reader.uint32()) };
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = { $case: "peerJoinMessage", peerJoinMessage: WsPeerJoin.decode(reader, reader.uint32()) };
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = {
+            $case: "peerUpdateMessage",
+            peerUpdateMessage: WsPeerUpdate.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.message = {
+            $case: "challengeMessage",
+            challengeMessage: WsChallengeRequired.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.message = {
+            $case: "signedChallengeForServer",
+            signedChallengeForServer: WsSignedChallenge.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.message = {
+            $case: "peerLeaveMessage",
+            peerLeaveMessage: WsPeerLeave.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.message = {
+            $case: "peerIdentification",
+            peerIdentification: WsIdentification.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+
+          message.message = { $case: "peerKicked", peerKicked: WsKicked.decode(reader, reader.uint32()) };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WsPacket {
+    return {
+      message: isSet(object.welcomeMessage)
+        ? { $case: "welcomeMessage", welcomeMessage: WsWelcome.fromJSON(object.welcomeMessage) }
+        : isSet(object.peerJoinMessage)
+        ? { $case: "peerJoinMessage", peerJoinMessage: WsPeerJoin.fromJSON(object.peerJoinMessage) }
+        : isSet(object.peerUpdateMessage)
+        ? { $case: "peerUpdateMessage", peerUpdateMessage: WsPeerUpdate.fromJSON(object.peerUpdateMessage) }
+        : isSet(object.challengeMessage)
+        ? { $case: "challengeMessage", challengeMessage: WsChallengeRequired.fromJSON(object.challengeMessage) }
+        : isSet(object.signedChallengeForServer)
+        ? {
+          $case: "signedChallengeForServer",
+          signedChallengeForServer: WsSignedChallenge.fromJSON(object.signedChallengeForServer),
+        }
+        : isSet(object.peerLeaveMessage)
+        ? { $case: "peerLeaveMessage", peerLeaveMessage: WsPeerLeave.fromJSON(object.peerLeaveMessage) }
+        : isSet(object.peerIdentification)
+        ? { $case: "peerIdentification", peerIdentification: WsIdentification.fromJSON(object.peerIdentification) }
+        : isSet(object.peerKicked)
+        ? { $case: "peerKicked", peerKicked: WsKicked.fromJSON(object.peerKicked) }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: WsPacket): unknown {
+    const obj: any = {};
+    message.message?.$case === "welcomeMessage" &&
+      (obj.welcomeMessage = message.message?.welcomeMessage
+        ? WsWelcome.toJSON(message.message?.welcomeMessage)
+        : undefined);
+    message.message?.$case === "peerJoinMessage" &&
+      (obj.peerJoinMessage = message.message?.peerJoinMessage
+        ? WsPeerJoin.toJSON(message.message?.peerJoinMessage)
+        : undefined);
+    message.message?.$case === "peerUpdateMessage" &&
+      (obj.peerUpdateMessage = message.message?.peerUpdateMessage
+        ? WsPeerUpdate.toJSON(message.message?.peerUpdateMessage)
+        : undefined);
+    message.message?.$case === "challengeMessage" &&
+      (obj.challengeMessage = message.message?.challengeMessage
+        ? WsChallengeRequired.toJSON(message.message?.challengeMessage)
+        : undefined);
+    message.message?.$case === "signedChallengeForServer" &&
+      (obj.signedChallengeForServer = message.message?.signedChallengeForServer
+        ? WsSignedChallenge.toJSON(message.message?.signedChallengeForServer)
+        : undefined);
+    message.message?.$case === "peerLeaveMessage" &&
+      (obj.peerLeaveMessage = message.message?.peerLeaveMessage
+        ? WsPeerLeave.toJSON(message.message?.peerLeaveMessage)
+        : undefined);
+    message.message?.$case === "peerIdentification" &&
+      (obj.peerIdentification = message.message?.peerIdentification
+        ? WsIdentification.toJSON(message.message?.peerIdentification)
+        : undefined);
+    message.message?.$case === "peerKicked" &&
+      (obj.peerKicked = message.message?.peerKicked ? WsKicked.toJSON(message.message?.peerKicked) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WsPacket>, I>>(base?: I): WsPacket {
+    return WsPacket.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WsPacket>, I>>(object: I): WsPacket {
+    const message = createBaseWsPacket();
+    if (
+      object.message?.$case === "welcomeMessage" &&
+      object.message?.welcomeMessage !== undefined &&
+      object.message?.welcomeMessage !== null
+    ) {
+      message.message = {
+        $case: "welcomeMessage",
+        welcomeMessage: WsWelcome.fromPartial(object.message.welcomeMessage),
+      };
+    }
+    if (
+      object.message?.$case === "peerJoinMessage" &&
+      object.message?.peerJoinMessage !== undefined &&
+      object.message?.peerJoinMessage !== null
+    ) {
+      message.message = {
+        $case: "peerJoinMessage",
+        peerJoinMessage: WsPeerJoin.fromPartial(object.message.peerJoinMessage),
+      };
+    }
+    if (
+      object.message?.$case === "peerUpdateMessage" &&
+      object.message?.peerUpdateMessage !== undefined &&
+      object.message?.peerUpdateMessage !== null
+    ) {
+      message.message = {
+        $case: "peerUpdateMessage",
+        peerUpdateMessage: WsPeerUpdate.fromPartial(object.message.peerUpdateMessage),
+      };
+    }
+    if (
+      object.message?.$case === "challengeMessage" &&
+      object.message?.challengeMessage !== undefined &&
+      object.message?.challengeMessage !== null
+    ) {
+      message.message = {
+        $case: "challengeMessage",
+        challengeMessage: WsChallengeRequired.fromPartial(object.message.challengeMessage),
+      };
+    }
+    if (
+      object.message?.$case === "signedChallengeForServer" &&
+      object.message?.signedChallengeForServer !== undefined &&
+      object.message?.signedChallengeForServer !== null
+    ) {
+      message.message = {
+        $case: "signedChallengeForServer",
+        signedChallengeForServer: WsSignedChallenge.fromPartial(object.message.signedChallengeForServer),
+      };
+    }
+    if (
+      object.message?.$case === "peerLeaveMessage" &&
+      object.message?.peerLeaveMessage !== undefined &&
+      object.message?.peerLeaveMessage !== null
+    ) {
+      message.message = {
+        $case: "peerLeaveMessage",
+        peerLeaveMessage: WsPeerLeave.fromPartial(object.message.peerLeaveMessage),
+      };
+    }
+    if (
+      object.message?.$case === "peerIdentification" &&
+      object.message?.peerIdentification !== undefined &&
+      object.message?.peerIdentification !== null
+    ) {
+      message.message = {
+        $case: "peerIdentification",
+        peerIdentification: WsIdentification.fromPartial(object.message.peerIdentification),
+      };
+    }
+    if (
+      object.message?.$case === "peerKicked" &&
+      object.message?.peerKicked !== undefined &&
+      object.message?.peerKicked !== null
+    ) {
+      message.message = { $case: "peerKicked", peerKicked: WsKicked.fromPartial(object.message.peerKicked) };
+    }
+    return message;
+  }
+}
+
+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
+  : 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 };
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}