@dcl/protocol 1.0.0-4659981125.commit-93719f9 → 1.0.0-4721150054.commit-85597a5

package/out-ts/decentraland/kernel/comms/v3/archipelago.gen.ts

@@ -1,57 +1,56 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
+import { Position } from "../../../common/vectors.gen";
 
 export const protobufPackage = "decentraland.kernel.comms.v3";
 
-export enum TransportType {
-  TT_LIVEKIT = 0,
-  TT_WS = 1,
+export enum KickedReason {
+  KR_NEW_SESSION = 0,
   UNRECOGNIZED = -1,
 }
 
-export function transportTypeFromJSON(object: any): TransportType {
+export function kickedReasonFromJSON(object: any): KickedReason {
   switch (object) {
     case 0:
-    case "TT_LIVEKIT":
-      return TransportType.TT_LIVEKIT;
-    case 1:
-    case "TT_WS":
-      return TransportType.TT_WS;
+    case "KR_NEW_SESSION":
+      return KickedReason.KR_NEW_SESSION;
     case -1:
     case "UNRECOGNIZED":
     default:
-      return TransportType.UNRECOGNIZED;
+      return KickedReason.UNRECOGNIZED;
   }
 }
 
-export function transportTypeToJSON(object: TransportType): string {
+export function kickedReasonToJSON(object: KickedReason): string {
   switch (object) {
-    case TransportType.TT_LIVEKIT:
-      return "TT_LIVEKIT";
-    case TransportType.TT_WS:
-      return "TT_WS";
-    case TransportType.UNRECOGNIZED:
+    case KickedReason.KR_NEW_SESSION:
+      return "KR_NEW_SESSION";
+    case KickedReason.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
   }
 }
 
-export interface Position3DMessage {
-  x: number;
-  y: number;
-  z: number;
+/** Server->Client messsages */
+export interface ChallengeResponseMessage {
+  challengeToSign: string;
+  alreadyConnected: boolean;
+}
+
+export interface WelcomeMessage {
+  peerId: string;
 }
 
 export interface IslandChangedMessage {
   islandId: string;
   connStr: string;
   fromIslandId?: string | undefined;
-  peers: { [key: string]: Position3DMessage };
+  peers: { [key: string]: Position };
 }
 
 export interface IslandChangedMessage_PeersEntry {
   key: string;
-  value: Position3DMessage | undefined;
+  value: Position | undefined;
 }
 
 export interface LeftIslandMessage {
@@ -64,96 +63,150 @@ export interface JoinIslandMessage {
   peerId: string;
 }
 
-export interface IslandData {
-  id: string;
-  peers: string[];
-  maxPeers: number;
-  center: Position3DMessage | undefined;
-  radius: number;
+export interface KickedMessage {
+  reason: KickedReason;
 }
 
-export interface IslandStatusMessage {
-  data: IslandData[];
+export interface ServerPacket {
+  message?:
+    | { $case: "challengeResponse"; challengeResponse: ChallengeResponseMessage }
+    | { $case: "welcome"; welcome: WelcomeMessage }
+    | { $case: "islandChanged"; islandChanged: IslandChangedMessage }
+    | { $case: "leftIsland"; leftIsland: LeftIslandMessage }
+    | { $case: "joinIsland"; joinIsland: JoinIslandMessage }
+    | { $case: "kicked"; kicked: KickedMessage };
 }
 
-export interface TransportInit {
-  type: TransportType;
-  maxIslandSize: number;
+/** Client->Server messsages */
+export interface ChallengeRequestMessage {
+  address: string;
 }
 
-export interface TransportHeartbeat {
-  availableSeats: number;
-  usersCount: number;
+export interface SignedChallengeMessage {
+  authChainJson: string;
 }
 
-export interface TransportAuthorizationRequest {
-  requestId: string;
-  roomId: string;
-  userIds: string[];
+export interface Heartbeat {
+  position: Position | undefined;
+  desiredRoom?: string | undefined;
 }
 
-export interface TransportAuthorizationResponse {
-  requestId: string;
-  connStrs: { [key: string]: string };
+export interface ClientPacket {
+  message?: { $case: "challengeRequest"; challengeRequest: ChallengeRequestMessage } | {
+    $case: "signedChallenge";
+    signedChallenge: SignedChallengeMessage;
+  } | { $case: "heartbeat"; heartbeat: Heartbeat };
 }
 
-export interface TransportAuthorizationResponse_ConnStrsEntry {
-  key: string;
-  value: string;
+/** Others */
+export interface IslandData {
+  id: string;
+  peers: string[];
+  maxPeers: number;
+  center: Position | undefined;
+  radius: number;
 }
 
-export interface TransportMessage {
-  message?: { $case: "init"; init: TransportInit } | { $case: "heartbeat"; heartbeat: TransportHeartbeat } | {
-    $case: "authRequest";
-    authRequest: TransportAuthorizationRequest;
-  } | { $case: "authResponse"; authResponse: TransportAuthorizationResponse };
+export interface IslandStatusMessage {
+  data: IslandData[];
 }
 
-function createBasePosition3DMessage(): Position3DMessage {
-  return { x: 0, y: 0, z: 0 };
+function createBaseChallengeResponseMessage(): ChallengeResponseMessage {
+  return { challengeToSign: "", alreadyConnected: false };
 }
 
-export const Position3DMessage = {
-  encode(message: Position3DMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.x !== 0) {
-      writer.uint32(9).double(message.x);
-    }
-    if (message.y !== 0) {
-      writer.uint32(17).double(message.y);
+export const ChallengeResponseMessage = {
+  encode(message: ChallengeResponseMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.challengeToSign !== "") {
+      writer.uint32(10).string(message.challengeToSign);
     }
-    if (message.z !== 0) {
-      writer.uint32(25).double(message.z);
+    if (message.alreadyConnected === true) {
+      writer.uint32(16).bool(message.alreadyConnected);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Position3DMessage {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ChallengeResponseMessage {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBasePosition3DMessage();
+    const message = createBaseChallengeResponseMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag != 9) {
+          if (tag != 10) {
             break;
           }
 
-          message.x = reader.double();
+          message.challengeToSign = reader.string();
           continue;
         case 2:
-          if (tag != 17) {
+          if (tag != 16) {
             break;
           }
 
-          message.y = reader.double();
+          message.alreadyConnected = reader.bool();
           continue;
-        case 3:
-          if (tag != 25) {
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ChallengeResponseMessage {
+    return {
+      challengeToSign: isSet(object.challengeToSign) ? String(object.challengeToSign) : "",
+      alreadyConnected: isSet(object.alreadyConnected) ? Boolean(object.alreadyConnected) : false,
+    };
+  },
+
+  toJSON(message: ChallengeResponseMessage): unknown {
+    const obj: any = {};
+    message.challengeToSign !== undefined && (obj.challengeToSign = message.challengeToSign);
+    message.alreadyConnected !== undefined && (obj.alreadyConnected = message.alreadyConnected);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ChallengeResponseMessage>, I>>(base?: I): ChallengeResponseMessage {
+    return ChallengeResponseMessage.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<ChallengeResponseMessage>, I>>(object: I): ChallengeResponseMessage {
+    const message = createBaseChallengeResponseMessage();
+    message.challengeToSign = object.challengeToSign ?? "";
+    message.alreadyConnected = object.alreadyConnected ?? false;
+    return message;
+  },
+};
+
+function createBaseWelcomeMessage(): WelcomeMessage {
+  return { peerId: "" };
+}
+
+export const WelcomeMessage = {
+  encode(message: WelcomeMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.peerId !== "") {
+      writer.uint32(10).string(message.peerId);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): WelcomeMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWelcomeMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag != 10) {
             break;
           }
 
-          message.z = reader.double();
+          message.peerId = reader.string();
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -164,31 +217,23 @@ export const Position3DMessage = {
     return message;
   },
 
-  fromJSON(object: any): Position3DMessage {
-    return {
-      x: isSet(object.x) ? Number(object.x) : 0,
-      y: isSet(object.y) ? Number(object.y) : 0,
-      z: isSet(object.z) ? Number(object.z) : 0,
-    };
+  fromJSON(object: any): WelcomeMessage {
+    return { peerId: isSet(object.peerId) ? String(object.peerId) : "" };
   },
 
-  toJSON(message: Position3DMessage): unknown {
+  toJSON(message: WelcomeMessage): unknown {
     const obj: any = {};
-    message.x !== undefined && (obj.x = message.x);
-    message.y !== undefined && (obj.y = message.y);
-    message.z !== undefined && (obj.z = message.z);
+    message.peerId !== undefined && (obj.peerId = message.peerId);
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<Position3DMessage>, I>>(base?: I): Position3DMessage {
-    return Position3DMessage.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<WelcomeMessage>, I>>(base?: I): WelcomeMessage {
+    return WelcomeMessage.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<Position3DMessage>, I>>(object: I): Position3DMessage {
-    const message = createBasePosition3DMessage();
-    message.x = object.x ?? 0;
-    message.y = object.y ?? 0;
-    message.z = object.z ?? 0;
+  fromPartial<I extends Exact<DeepPartial<WelcomeMessage>, I>>(object: I): WelcomeMessage {
+    const message = createBaseWelcomeMessage();
+    message.peerId = object.peerId ?? "";
     return message;
   },
 };
@@ -267,8 +312,8 @@ export const IslandChangedMessage = {
       connStr: isSet(object.connStr) ? String(object.connStr) : "",
       fromIslandId: isSet(object.fromIslandId) ? String(object.fromIslandId) : undefined,
       peers: isObject(object.peers)
-        ? Object.entries(object.peers).reduce<{ [key: string]: Position3DMessage }>((acc, [key, value]) => {
-          acc[key] = Position3DMessage.fromJSON(value);
+        ? Object.entries(object.peers).reduce<{ [key: string]: Position }>((acc, [key, value]) => {
+          acc[key] = Position.fromJSON(value);
           return acc;
         }, {})
         : {},
@@ -283,7 +328,7 @@ export const IslandChangedMessage = {
     obj.peers = {};
     if (message.peers) {
       Object.entries(message.peers).forEach(([k, v]) => {
-        obj.peers[k] = Position3DMessage.toJSON(v);
+        obj.peers[k] = Position.toJSON(v);
       });
     }
     return obj;
@@ -298,15 +343,12 @@ export const IslandChangedMessage = {
     message.islandId = object.islandId ?? "";
     message.connStr = object.connStr ?? "";
     message.fromIslandId = object.fromIslandId ?? undefined;
-    message.peers = Object.entries(object.peers ?? {}).reduce<{ [key: string]: Position3DMessage }>(
-      (acc, [key, value]) => {
-        if (value !== undefined) {
-          acc[key] = Position3DMessage.fromPartial(value);
-        }
-        return acc;
-      },
-      {},
-    );
+    message.peers = Object.entries(object.peers ?? {}).reduce<{ [key: string]: Position }>((acc, [key, value]) => {
+      if (value !== undefined) {
+        acc[key] = Position.fromPartial(value);
+      }
+      return acc;
+    }, {});
     return message;
   },
 };
@@ -321,7 +363,7 @@ export const IslandChangedMessage_PeersEntry = {
       writer.uint32(10).string(message.key);
     }
     if (message.value !== undefined) {
-      Position3DMessage.encode(message.value, writer.uint32(18).fork()).ldelim();
+      Position.encode(message.value, writer.uint32(18).fork()).ldelim();
     }
     return writer;
   },
@@ -345,7 +387,7 @@ export const IslandChangedMessage_PeersEntry = {
             break;
           }
 
-          message.value = Position3DMessage.decode(reader, reader.uint32());
+          message.value = Position.decode(reader, reader.uint32());
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -359,14 +401,14 @@ export const IslandChangedMessage_PeersEntry = {
   fromJSON(object: any): IslandChangedMessage_PeersEntry {
     return {
       key: isSet(object.key) ? String(object.key) : "",
-      value: isSet(object.value) ? Position3DMessage.fromJSON(object.value) : undefined,
+      value: isSet(object.value) ? Position.fromJSON(object.value) : undefined,
     };
   },
 
   toJSON(message: IslandChangedMessage_PeersEntry): unknown {
     const obj: any = {};
     message.key !== undefined && (obj.key = message.key);
-    message.value !== undefined && (obj.value = message.value ? Position3DMessage.toJSON(message.value) : undefined);
+    message.value !== undefined && (obj.value = message.value ? Position.toJSON(message.value) : undefined);
     return obj;
   },
 
@@ -380,7 +422,7 @@ export const IslandChangedMessage_PeersEntry = {
     const message = createBaseIslandChangedMessage_PeersEntry();
     message.key = object.key ?? "";
     message.value = (object.value !== undefined && object.value !== null)
-      ? Position3DMessage.fromPartial(object.value)
+      ? Position.fromPartial(object.value)
       : undefined;
     return message;
   },
@@ -528,34 +570,95 @@ export const JoinIslandMessage = {
   },
 };
 
-function createBaseIslandData(): IslandData {
-  return { id: "", peers: [], maxPeers: 0, center: undefined, radius: 0 };
+function createBaseKickedMessage(): KickedMessage {
+  return { reason: 0 };
 }
 
-export const IslandData = {
-  encode(message: IslandData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.id !== "") {
-      writer.uint32(10).string(message.id);
-    }
-    for (const v of message.peers) {
-      writer.uint32(18).string(v!);
-    }
-    if (message.maxPeers !== 0) {
-      writer.uint32(24).uint32(message.maxPeers);
+export const KickedMessage = {
+  encode(message: KickedMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.reason !== 0) {
+      writer.uint32(8).int32(message.reason);
     }
-    if (message.center !== undefined) {
-      Position3DMessage.encode(message.center, writer.uint32(34).fork()).ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): KickedMessage {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseKickedMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag != 8) {
+            break;
+          }
+
+          message.reason = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
-    if (message.radius !== 0) {
-      writer.uint32(41).double(message.radius);
+    return message;
+  },
+
+  fromJSON(object: any): KickedMessage {
+    return { reason: isSet(object.reason) ? kickedReasonFromJSON(object.reason) : 0 };
+  },
+
+  toJSON(message: KickedMessage): unknown {
+    const obj: any = {};
+    message.reason !== undefined && (obj.reason = kickedReasonToJSON(message.reason));
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<KickedMessage>, I>>(base?: I): KickedMessage {
+    return KickedMessage.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<KickedMessage>, I>>(object: I): KickedMessage {
+    const message = createBaseKickedMessage();
+    message.reason = object.reason ?? 0;
+    return message;
+  },
+};
+
+function createBaseServerPacket(): ServerPacket {
+  return { message: undefined };
+}
+
+export const ServerPacket = {
+  encode(message: ServerPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.message?.$case) {
+      case "challengeResponse":
+        ChallengeResponseMessage.encode(message.message.challengeResponse, writer.uint32(10).fork()).ldelim();
+        break;
+      case "welcome":
+        WelcomeMessage.encode(message.message.welcome, writer.uint32(18).fork()).ldelim();
+        break;
+      case "islandChanged":
+        IslandChangedMessage.encode(message.message.islandChanged, writer.uint32(26).fork()).ldelim();
+        break;
+      case "leftIsland":
+        LeftIslandMessage.encode(message.message.leftIsland, writer.uint32(34).fork()).ldelim();
+        break;
+      case "joinIsland":
+        JoinIslandMessage.encode(message.message.joinIsland, writer.uint32(42).fork()).ldelim();
+        break;
+      case "kicked":
+        KickedMessage.encode(message.message.kicked, writer.uint32(50).fork()).ldelim();
+        break;
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): IslandData {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ServerPacket {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseIslandData();
+    const message = createBaseServerPacket();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -564,35 +667,48 @@ export const IslandData = {
             break;
           }
 
-          message.id = reader.string();
+          message.message = {
+            $case: "challengeResponse",
+            challengeResponse: ChallengeResponseMessage.decode(reader, reader.uint32()),
+          };
           continue;
         case 2:
           if (tag != 18) {
             break;
           }
 
-          message.peers.push(reader.string());
+          message.message = { $case: "welcome", welcome: WelcomeMessage.decode(reader, reader.uint32()) };
           continue;
         case 3:
-          if (tag != 24) {
+          if (tag != 26) {
             break;
           }
 
-          message.maxPeers = reader.uint32();
+          message.message = {
+            $case: "islandChanged",
+            islandChanged: IslandChangedMessage.decode(reader, reader.uint32()),
+          };
           continue;
         case 4:
           if (tag != 34) {
             break;
           }
 
-          message.center = Position3DMessage.decode(reader, reader.uint32());
+          message.message = { $case: "leftIsland", leftIsland: LeftIslandMessage.decode(reader, reader.uint32()) };
           continue;
         case 5:
-          if (tag != 41) {
+          if (tag != 42) {
             break;
           }
 
-          message.radius = reader.double();
+          message.message = { $case: "joinIsland", joinIsland: JoinIslandMessage.decode(reader, reader.uint32()) };
+          continue;
+        case 6:
+          if (tag != 50) {
+            break;
+          }
+
+          message.message = { $case: "kicked", kicked: KickedMessage.decode(reader, reader.uint32()) };
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -603,64 +719,115 @@ export const IslandData = {
     return message;
   },
 
-  fromJSON(object: any): IslandData {
+  fromJSON(object: any): ServerPacket {
     return {
-      id: isSet(object.id) ? String(object.id) : "",
-      peers: Array.isArray(object?.peers) ? object.peers.map((e: any) => String(e)) : [],
-      maxPeers: isSet(object.maxPeers) ? Number(object.maxPeers) : 0,
-      center: isSet(object.center) ? Position3DMessage.fromJSON(object.center) : undefined,
-      radius: isSet(object.radius) ? Number(object.radius) : 0,
+      message: isSet(object.challengeResponse)
+        ? { $case: "challengeResponse", challengeResponse: ChallengeResponseMessage.fromJSON(object.challengeResponse) }
+        : isSet(object.welcome)
+        ? { $case: "welcome", welcome: WelcomeMessage.fromJSON(object.welcome) }
+        : isSet(object.islandChanged)
+        ? { $case: "islandChanged", islandChanged: IslandChangedMessage.fromJSON(object.islandChanged) }
+        : isSet(object.leftIsland)
+        ? { $case: "leftIsland", leftIsland: LeftIslandMessage.fromJSON(object.leftIsland) }
+        : isSet(object.joinIsland)
+        ? { $case: "joinIsland", joinIsland: JoinIslandMessage.fromJSON(object.joinIsland) }
+        : isSet(object.kicked)
+        ? { $case: "kicked", kicked: KickedMessage.fromJSON(object.kicked) }
+        : undefined,
     };
   },
 
-  toJSON(message: IslandData): unknown {
+  toJSON(message: ServerPacket): unknown {
     const obj: any = {};
-    message.id !== undefined && (obj.id = message.id);
-    if (message.peers) {
-      obj.peers = message.peers.map((e) => e);
-    } else {
-      obj.peers = [];
-    }
-    message.maxPeers !== undefined && (obj.maxPeers = Math.round(message.maxPeers));
-    message.center !== undefined &&
-      (obj.center = message.center ? Position3DMessage.toJSON(message.center) : undefined);
-    message.radius !== undefined && (obj.radius = message.radius);
+    message.message?.$case === "challengeResponse" && (obj.challengeResponse = message.message?.challengeResponse
+      ? ChallengeResponseMessage.toJSON(message.message?.challengeResponse)
+      : undefined);
+    message.message?.$case === "welcome" &&
+      (obj.welcome = message.message?.welcome ? WelcomeMessage.toJSON(message.message?.welcome) : undefined);
+    message.message?.$case === "islandChanged" && (obj.islandChanged = message.message?.islandChanged
+      ? IslandChangedMessage.toJSON(message.message?.islandChanged)
+      : undefined);
+    message.message?.$case === "leftIsland" &&
+      (obj.leftIsland = message.message?.leftIsland
+        ? LeftIslandMessage.toJSON(message.message?.leftIsland)
+        : undefined);
+    message.message?.$case === "joinIsland" &&
+      (obj.joinIsland = message.message?.joinIsland
+        ? JoinIslandMessage.toJSON(message.message?.joinIsland)
+        : undefined);
+    message.message?.$case === "kicked" &&
+      (obj.kicked = message.message?.kicked ? KickedMessage.toJSON(message.message?.kicked) : undefined);
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<IslandData>, I>>(base?: I): IslandData {
-    return IslandData.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<ServerPacket>, I>>(base?: I): ServerPacket {
+    return ServerPacket.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<IslandData>, I>>(object: I): IslandData {
-    const message = createBaseIslandData();
-    message.id = object.id ?? "";
-    message.peers = object.peers?.map((e) => e) || [];
-    message.maxPeers = object.maxPeers ?? 0;
-    message.center = (object.center !== undefined && object.center !== null)
-      ? Position3DMessage.fromPartial(object.center)
-      : undefined;
-    message.radius = object.radius ?? 0;
+  fromPartial<I extends Exact<DeepPartial<ServerPacket>, I>>(object: I): ServerPacket {
+    const message = createBaseServerPacket();
+    if (
+      object.message?.$case === "challengeResponse" &&
+      object.message?.challengeResponse !== undefined &&
+      object.message?.challengeResponse !== null
+    ) {
+      message.message = {
+        $case: "challengeResponse",
+        challengeResponse: ChallengeResponseMessage.fromPartial(object.message.challengeResponse),
+      };
+    }
+    if (
+      object.message?.$case === "welcome" && object.message?.welcome !== undefined && object.message?.welcome !== null
+    ) {
+      message.message = { $case: "welcome", welcome: WelcomeMessage.fromPartial(object.message.welcome) };
+    }
+    if (
+      object.message?.$case === "islandChanged" &&
+      object.message?.islandChanged !== undefined &&
+      object.message?.islandChanged !== null
+    ) {
+      message.message = {
+        $case: "islandChanged",
+        islandChanged: IslandChangedMessage.fromPartial(object.message.islandChanged),
+      };
+    }
+    if (
+      object.message?.$case === "leftIsland" &&
+      object.message?.leftIsland !== undefined &&
+      object.message?.leftIsland !== null
+    ) {
+      message.message = { $case: "leftIsland", leftIsland: LeftIslandMessage.fromPartial(object.message.leftIsland) };
+    }
+    if (
+      object.message?.$case === "joinIsland" &&
+      object.message?.joinIsland !== undefined &&
+      object.message?.joinIsland !== null
+    ) {
+      message.message = { $case: "joinIsland", joinIsland: JoinIslandMessage.fromPartial(object.message.joinIsland) };
+    }
+    if (object.message?.$case === "kicked" && object.message?.kicked !== undefined && object.message?.kicked !== null) {
+      message.message = { $case: "kicked", kicked: KickedMessage.fromPartial(object.message.kicked) };
+    }
     return message;
   },
 };
 
-function createBaseIslandStatusMessage(): IslandStatusMessage {
-  return { data: [] };
+function createBaseChallengeRequestMessage(): ChallengeRequestMessage {
+  return { address: "" };
 }
 
-export const IslandStatusMessage = {
-  encode(message: IslandStatusMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    for (const v of message.data) {
-      IslandData.encode(v!, writer.uint32(10).fork()).ldelim();
+export const ChallengeRequestMessage = {
+  encode(message: ChallengeRequestMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): IslandStatusMessage {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ChallengeRequestMessage {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseIslandStatusMessage();
+    const message = createBaseChallengeRequestMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -669,7 +836,7 @@ export const IslandStatusMessage = {
             break;
           }
 
-          message.data.push(IslandData.decode(reader, reader.uint32()));
+          message.address = reader.string();
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -680,66 +847,52 @@ export const IslandStatusMessage = {
     return message;
   },
 
-  fromJSON(object: any): IslandStatusMessage {
-    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => IslandData.fromJSON(e)) : [] };
+  fromJSON(object: any): ChallengeRequestMessage {
+    return { address: isSet(object.address) ? String(object.address) : "" };
   },
 
-  toJSON(message: IslandStatusMessage): unknown {
+  toJSON(message: ChallengeRequestMessage): unknown {
     const obj: any = {};
-    if (message.data) {
-      obj.data = message.data.map((e) => e ? IslandData.toJSON(e) : undefined);
-    } else {
-      obj.data = [];
-    }
+    message.address !== undefined && (obj.address = message.address);
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<IslandStatusMessage>, I>>(base?: I): IslandStatusMessage {
-    return IslandStatusMessage.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<ChallengeRequestMessage>, I>>(base?: I): ChallengeRequestMessage {
+    return ChallengeRequestMessage.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<IslandStatusMessage>, I>>(object: I): IslandStatusMessage {
-    const message = createBaseIslandStatusMessage();
-    message.data = object.data?.map((e) => IslandData.fromPartial(e)) || [];
+  fromPartial<I extends Exact<DeepPartial<ChallengeRequestMessage>, I>>(object: I): ChallengeRequestMessage {
+    const message = createBaseChallengeRequestMessage();
+    message.address = object.address ?? "";
     return message;
   },
 };
 
-function createBaseTransportInit(): TransportInit {
-  return { type: 0, maxIslandSize: 0 };
+function createBaseSignedChallengeMessage(): SignedChallengeMessage {
+  return { authChainJson: "" };
 }
 
-export const TransportInit = {
-  encode(message: TransportInit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.type !== 0) {
-      writer.uint32(8).int32(message.type);
-    }
-    if (message.maxIslandSize !== 0) {
-      writer.uint32(16).uint32(message.maxIslandSize);
+export const SignedChallengeMessage = {
+  encode(message: SignedChallengeMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.authChainJson !== "") {
+      writer.uint32(10).string(message.authChainJson);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportInit {
+  decode(input: _m0.Reader | Uint8Array, length?: number): SignedChallengeMessage {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportInit();
+    const message = createBaseSignedChallengeMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag != 8) {
-            break;
-          }
-
-          message.type = reader.int32() as any;
-          continue;
-        case 2:
-          if (tag != 16) {
+          if (tag != 10) {
             break;
           }
 
-          message.maxIslandSize = reader.uint32();
+          message.authChainJson = reader.string();
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -750,67 +903,62 @@ export const TransportInit = {
     return message;
   },
 
-  fromJSON(object: any): TransportInit {
-    return {
-      type: isSet(object.type) ? transportTypeFromJSON(object.type) : 0,
-      maxIslandSize: isSet(object.maxIslandSize) ? Number(object.maxIslandSize) : 0,
-    };
+  fromJSON(object: any): SignedChallengeMessage {
+    return { authChainJson: isSet(object.authChainJson) ? String(object.authChainJson) : "" };
   },
 
-  toJSON(message: TransportInit): unknown {
+  toJSON(message: SignedChallengeMessage): unknown {
     const obj: any = {};
-    message.type !== undefined && (obj.type = transportTypeToJSON(message.type));
-    message.maxIslandSize !== undefined && (obj.maxIslandSize = Math.round(message.maxIslandSize));
+    message.authChainJson !== undefined && (obj.authChainJson = message.authChainJson);
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TransportInit>, I>>(base?: I): TransportInit {
-    return TransportInit.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<SignedChallengeMessage>, I>>(base?: I): SignedChallengeMessage {
+    return SignedChallengeMessage.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<TransportInit>, I>>(object: I): TransportInit {
-    const message = createBaseTransportInit();
-    message.type = object.type ?? 0;
-    message.maxIslandSize = object.maxIslandSize ?? 0;
+  fromPartial<I extends Exact<DeepPartial<SignedChallengeMessage>, I>>(object: I): SignedChallengeMessage {
+    const message = createBaseSignedChallengeMessage();
+    message.authChainJson = object.authChainJson ?? "";
     return message;
   },
 };
 
-function createBaseTransportHeartbeat(): TransportHeartbeat {
-  return { availableSeats: 0, usersCount: 0 };
+function createBaseHeartbeat(): Heartbeat {
+  return { position: undefined, desiredRoom: undefined };
 }
 
-export const TransportHeartbeat = {
-  encode(message: TransportHeartbeat, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.availableSeats !== 0) {
-      writer.uint32(8).uint32(message.availableSeats);
+export const Heartbeat = {
+  encode(message: Heartbeat, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.position !== undefined) {
+      Position.encode(message.position, writer.uint32(10).fork()).ldelim();
     }
-    if (message.usersCount !== 0) {
-      writer.uint32(16).uint32(message.usersCount);
+    if (message.desiredRoom !== undefined) {
+      writer.uint32(18).string(message.desiredRoom);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportHeartbeat {
+  decode(input: _m0.Reader | Uint8Array, length?: number): Heartbeat {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportHeartbeat();
+    const message = createBaseHeartbeat();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if (tag != 8) {
+          if (tag != 10) {
             break;
           }
 
-          message.availableSeats = reader.uint32();
+          message.position = Position.decode(reader, reader.uint32());
           continue;
         case 2:
-          if (tag != 16) {
+          if (tag != 18) {
             break;
           }
 
-          message.usersCount = reader.uint32();
+          message.desiredRoom = reader.string();
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -821,54 +969,58 @@ export const TransportHeartbeat = {
     return message;
   },
 
-  fromJSON(object: any): TransportHeartbeat {
+  fromJSON(object: any): Heartbeat {
     return {
-      availableSeats: isSet(object.availableSeats) ? Number(object.availableSeats) : 0,
-      usersCount: isSet(object.usersCount) ? Number(object.usersCount) : 0,
+      position: isSet(object.position) ? Position.fromJSON(object.position) : undefined,
+      desiredRoom: isSet(object.desiredRoom) ? String(object.desiredRoom) : undefined,
     };
   },
 
-  toJSON(message: TransportHeartbeat): unknown {
+  toJSON(message: Heartbeat): unknown {
     const obj: any = {};
-    message.availableSeats !== undefined && (obj.availableSeats = Math.round(message.availableSeats));
-    message.usersCount !== undefined && (obj.usersCount = Math.round(message.usersCount));
+    message.position !== undefined && (obj.position = message.position ? Position.toJSON(message.position) : undefined);
+    message.desiredRoom !== undefined && (obj.desiredRoom = message.desiredRoom);
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TransportHeartbeat>, I>>(base?: I): TransportHeartbeat {
-    return TransportHeartbeat.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<Heartbeat>, I>>(base?: I): Heartbeat {
+    return Heartbeat.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<TransportHeartbeat>, I>>(object: I): TransportHeartbeat {
-    const message = createBaseTransportHeartbeat();
-    message.availableSeats = object.availableSeats ?? 0;
-    message.usersCount = object.usersCount ?? 0;
+  fromPartial<I extends Exact<DeepPartial<Heartbeat>, I>>(object: I): Heartbeat {
+    const message = createBaseHeartbeat();
+    message.position = (object.position !== undefined && object.position !== null)
+      ? Position.fromPartial(object.position)
+      : undefined;
+    message.desiredRoom = object.desiredRoom ?? undefined;
     return message;
   },
 };
 
-function createBaseTransportAuthorizationRequest(): TransportAuthorizationRequest {
-  return { requestId: "", roomId: "", userIds: [] };
+function createBaseClientPacket(): ClientPacket {
+  return { message: undefined };
 }
 
-export const TransportAuthorizationRequest = {
-  encode(message: TransportAuthorizationRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.requestId !== "") {
-      writer.uint32(10).string(message.requestId);
-    }
-    if (message.roomId !== "") {
-      writer.uint32(18).string(message.roomId);
-    }
-    for (const v of message.userIds) {
-      writer.uint32(26).string(v!);
+export const ClientPacket = {
+  encode(message: ClientPacket, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    switch (message.message?.$case) {
+      case "challengeRequest":
+        ChallengeRequestMessage.encode(message.message.challengeRequest, writer.uint32(10).fork()).ldelim();
+        break;
+      case "signedChallenge":
+        SignedChallengeMessage.encode(message.message.signedChallenge, writer.uint32(18).fork()).ldelim();
+        break;
+      case "heartbeat":
+        Heartbeat.encode(message.message.heartbeat, writer.uint32(26).fork()).ldelim();
+        break;
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportAuthorizationRequest {
+  decode(input: _m0.Reader | Uint8Array, length?: number): ClientPacket {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportAuthorizationRequest();
+    const message = createBaseClientPacket();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -877,21 +1029,27 @@ export const TransportAuthorizationRequest = {
             break;
           }
 
-          message.requestId = reader.string();
+          message.message = {
+            $case: "challengeRequest",
+            challengeRequest: ChallengeRequestMessage.decode(reader, reader.uint32()),
+          };
           continue;
         case 2:
           if (tag != 18) {
             break;
           }
 
-          message.roomId = reader.string();
+          message.message = {
+            $case: "signedChallenge",
+            signedChallenge: SignedChallengeMessage.decode(reader, reader.uint32()),
+          };
           continue;
         case 3:
           if (tag != 26) {
             break;
           }
 
-          message.userIds.push(reader.string());
+          message.message = { $case: "heartbeat", heartbeat: Heartbeat.decode(reader, reader.uint32()) };
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -902,61 +1060,96 @@ export const TransportAuthorizationRequest = {
     return message;
   },
 
-  fromJSON(object: any): TransportAuthorizationRequest {
+  fromJSON(object: any): ClientPacket {
     return {
-      requestId: isSet(object.requestId) ? String(object.requestId) : "",
-      roomId: isSet(object.roomId) ? String(object.roomId) : "",
-      userIds: Array.isArray(object?.userIds) ? object.userIds.map((e: any) => String(e)) : [],
+      message: isSet(object.challengeRequest)
+        ? { $case: "challengeRequest", challengeRequest: ChallengeRequestMessage.fromJSON(object.challengeRequest) }
+        : isSet(object.signedChallenge)
+        ? { $case: "signedChallenge", signedChallenge: SignedChallengeMessage.fromJSON(object.signedChallenge) }
+        : isSet(object.heartbeat)
+        ? { $case: "heartbeat", heartbeat: Heartbeat.fromJSON(object.heartbeat) }
+        : undefined,
     };
   },
 
-  toJSON(message: TransportAuthorizationRequest): unknown {
+  toJSON(message: ClientPacket): unknown {
     const obj: any = {};
-    message.requestId !== undefined && (obj.requestId = message.requestId);
-    message.roomId !== undefined && (obj.roomId = message.roomId);
-    if (message.userIds) {
-      obj.userIds = message.userIds.map((e) => e);
-    } else {
-      obj.userIds = [];
-    }
+    message.message?.$case === "challengeRequest" && (obj.challengeRequest = message.message?.challengeRequest
+      ? ChallengeRequestMessage.toJSON(message.message?.challengeRequest)
+      : undefined);
+    message.message?.$case === "signedChallenge" && (obj.signedChallenge = message.message?.signedChallenge
+      ? SignedChallengeMessage.toJSON(message.message?.signedChallenge)
+      : undefined);
+    message.message?.$case === "heartbeat" &&
+      (obj.heartbeat = message.message?.heartbeat ? Heartbeat.toJSON(message.message?.heartbeat) : undefined);
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TransportAuthorizationRequest>, I>>(base?: I): TransportAuthorizationRequest {
-    return TransportAuthorizationRequest.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<ClientPacket>, I>>(base?: I): ClientPacket {
+    return ClientPacket.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<TransportAuthorizationRequest>, I>>(
-    object: I,
-  ): TransportAuthorizationRequest {
-    const message = createBaseTransportAuthorizationRequest();
-    message.requestId = object.requestId ?? "";
-    message.roomId = object.roomId ?? "";
-    message.userIds = object.userIds?.map((e) => e) || [];
+  fromPartial<I extends Exact<DeepPartial<ClientPacket>, I>>(object: I): ClientPacket {
+    const message = createBaseClientPacket();
+    if (
+      object.message?.$case === "challengeRequest" &&
+      object.message?.challengeRequest !== undefined &&
+      object.message?.challengeRequest !== null
+    ) {
+      message.message = {
+        $case: "challengeRequest",
+        challengeRequest: ChallengeRequestMessage.fromPartial(object.message.challengeRequest),
+      };
+    }
+    if (
+      object.message?.$case === "signedChallenge" &&
+      object.message?.signedChallenge !== undefined &&
+      object.message?.signedChallenge !== null
+    ) {
+      message.message = {
+        $case: "signedChallenge",
+        signedChallenge: SignedChallengeMessage.fromPartial(object.message.signedChallenge),
+      };
+    }
+    if (
+      object.message?.$case === "heartbeat" &&
+      object.message?.heartbeat !== undefined &&
+      object.message?.heartbeat !== null
+    ) {
+      message.message = { $case: "heartbeat", heartbeat: Heartbeat.fromPartial(object.message.heartbeat) };
+    }
     return message;
   },
 };
 
-function createBaseTransportAuthorizationResponse(): TransportAuthorizationResponse {
-  return { requestId: "", connStrs: {} };
+function createBaseIslandData(): IslandData {
+  return { id: "", peers: [], maxPeers: 0, center: undefined, radius: 0 };
 }
 
-export const TransportAuthorizationResponse = {
-  encode(message: TransportAuthorizationResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.requestId !== "") {
-      writer.uint32(10).string(message.requestId);
+export const IslandData = {
+  encode(message: IslandData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    for (const v of message.peers) {
+      writer.uint32(18).string(v!);
+    }
+    if (message.maxPeers !== 0) {
+      writer.uint32(24).uint32(message.maxPeers);
+    }
+    if (message.center !== undefined) {
+      Position.encode(message.center, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.radius !== 0) {
+      writer.uint32(41).double(message.radius);
     }
-    Object.entries(message.connStrs).forEach(([key, value]) => {
-      TransportAuthorizationResponse_ConnStrsEntry.encode({ key: key as any, value }, writer.uint32(18).fork())
-        .ldelim();
-    });
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportAuthorizationResponse {
+  decode(input: _m0.Reader | Uint8Array, length?: number): IslandData {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportAuthorizationResponse();
+    const message = createBaseIslandData();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -965,105 +1158,35 @@ export const TransportAuthorizationResponse = {
             break;
           }
 
-          message.requestId = reader.string();
+          message.id = reader.string();
           continue;
         case 2:
           if (tag != 18) {
             break;
           }
 
-          const entry2 = TransportAuthorizationResponse_ConnStrsEntry.decode(reader, reader.uint32());
-          if (entry2.value !== undefined) {
-            message.connStrs[entry2.key] = entry2.value;
-          }
+          message.peers.push(reader.string());
           continue;
-      }
-      if ((tag & 7) == 4 || tag == 0) {
-        break;
-      }
-      reader.skipType(tag & 7);
-    }
-    return message;
-  },
-
-  fromJSON(object: any): TransportAuthorizationResponse {
-    return {
-      requestId: isSet(object.requestId) ? String(object.requestId) : "",
-      connStrs: isObject(object.connStrs)
-        ? Object.entries(object.connStrs).reduce<{ [key: string]: string }>((acc, [key, value]) => {
-          acc[key] = String(value);
-          return acc;
-        }, {})
-        : {},
-    };
-  },
-
-  toJSON(message: TransportAuthorizationResponse): unknown {
-    const obj: any = {};
-    message.requestId !== undefined && (obj.requestId = message.requestId);
-    obj.connStrs = {};
-    if (message.connStrs) {
-      Object.entries(message.connStrs).forEach(([k, v]) => {
-        obj.connStrs[k] = v;
-      });
-    }
-    return obj;
-  },
-
-  create<I extends Exact<DeepPartial<TransportAuthorizationResponse>, I>>(base?: I): TransportAuthorizationResponse {
-    return TransportAuthorizationResponse.fromPartial(base ?? {});
-  },
-
-  fromPartial<I extends Exact<DeepPartial<TransportAuthorizationResponse>, I>>(
-    object: I,
-  ): TransportAuthorizationResponse {
-    const message = createBaseTransportAuthorizationResponse();
-    message.requestId = object.requestId ?? "";
-    message.connStrs = Object.entries(object.connStrs ?? {}).reduce<{ [key: string]: string }>((acc, [key, value]) => {
-      if (value !== undefined) {
-        acc[key] = String(value);
-      }
-      return acc;
-    }, {});
-    return message;
-  },
-};
-
-function createBaseTransportAuthorizationResponse_ConnStrsEntry(): TransportAuthorizationResponse_ConnStrsEntry {
-  return { key: "", value: "" };
-}
-
-export const TransportAuthorizationResponse_ConnStrsEntry = {
-  encode(message: TransportAuthorizationResponse_ConnStrsEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.key !== "") {
-      writer.uint32(10).string(message.key);
-    }
-    if (message.value !== "") {
-      writer.uint32(18).string(message.value);
-    }
-    return writer;
-  },
+        case 3:
+          if (tag != 24) {
+            break;
+          }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportAuthorizationResponse_ConnStrsEntry {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportAuthorizationResponse_ConnStrsEntry();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          if (tag != 10) {
+          message.maxPeers = reader.uint32();
+          continue;
+        case 4:
+          if (tag != 34) {
             break;
           }
 
-          message.key = reader.string();
+          message.center = Position.decode(reader, reader.uint32());
           continue;
-        case 2:
-          if (tag != 18) {
+        case 5:
+          if (tag != 41) {
             break;
           }
 
-          message.value = reader.string();
+          message.radius = reader.double();
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -1074,60 +1197,63 @@ export const TransportAuthorizationResponse_ConnStrsEntry = {
     return message;
   },
 
-  fromJSON(object: any): TransportAuthorizationResponse_ConnStrsEntry {
-    return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object.value) ? String(object.value) : "" };
+  fromJSON(object: any): IslandData {
+    return {
+      id: isSet(object.id) ? String(object.id) : "",
+      peers: Array.isArray(object?.peers) ? object.peers.map((e: any) => String(e)) : [],
+      maxPeers: isSet(object.maxPeers) ? Number(object.maxPeers) : 0,
+      center: isSet(object.center) ? Position.fromJSON(object.center) : undefined,
+      radius: isSet(object.radius) ? Number(object.radius) : 0,
+    };
   },
 
-  toJSON(message: TransportAuthorizationResponse_ConnStrsEntry): unknown {
+  toJSON(message: IslandData): unknown {
     const obj: any = {};
-    message.key !== undefined && (obj.key = message.key);
-    message.value !== undefined && (obj.value = message.value);
+    message.id !== undefined && (obj.id = message.id);
+    if (message.peers) {
+      obj.peers = message.peers.map((e) => e);
+    } else {
+      obj.peers = [];
+    }
+    message.maxPeers !== undefined && (obj.maxPeers = Math.round(message.maxPeers));
+    message.center !== undefined && (obj.center = message.center ? Position.toJSON(message.center) : undefined);
+    message.radius !== undefined && (obj.radius = message.radius);
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TransportAuthorizationResponse_ConnStrsEntry>, I>>(
-    base?: I,
-  ): TransportAuthorizationResponse_ConnStrsEntry {
-    return TransportAuthorizationResponse_ConnStrsEntry.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<IslandData>, I>>(base?: I): IslandData {
+    return IslandData.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<TransportAuthorizationResponse_ConnStrsEntry>, I>>(
-    object: I,
-  ): TransportAuthorizationResponse_ConnStrsEntry {
-    const message = createBaseTransportAuthorizationResponse_ConnStrsEntry();
-    message.key = object.key ?? "";
-    message.value = object.value ?? "";
+  fromPartial<I extends Exact<DeepPartial<IslandData>, I>>(object: I): IslandData {
+    const message = createBaseIslandData();
+    message.id = object.id ?? "";
+    message.peers = object.peers?.map((e) => e) || [];
+    message.maxPeers = object.maxPeers ?? 0;
+    message.center = (object.center !== undefined && object.center !== null)
+      ? Position.fromPartial(object.center)
+      : undefined;
+    message.radius = object.radius ?? 0;
     return message;
   },
 };
 
-function createBaseTransportMessage(): TransportMessage {
-  return { message: undefined };
+function createBaseIslandStatusMessage(): IslandStatusMessage {
+  return { data: [] };
 }
 
-export const TransportMessage = {
-  encode(message: TransportMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    switch (message.message?.$case) {
-      case "init":
-        TransportInit.encode(message.message.init, writer.uint32(10).fork()).ldelim();
-        break;
-      case "heartbeat":
-        TransportHeartbeat.encode(message.message.heartbeat, writer.uint32(18).fork()).ldelim();
-        break;
-      case "authRequest":
-        TransportAuthorizationRequest.encode(message.message.authRequest, writer.uint32(26).fork()).ldelim();
-        break;
-      case "authResponse":
-        TransportAuthorizationResponse.encode(message.message.authResponse, writer.uint32(34).fork()).ldelim();
-        break;
+export const IslandStatusMessage = {
+  encode(message: IslandStatusMessage, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      IslandData.encode(v!, writer.uint32(10).fork()).ldelim();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TransportMessage {
+  decode(input: _m0.Reader | Uint8Array, length?: number): IslandStatusMessage {
     const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTransportMessage();
+    const message = createBaseIslandStatusMessage();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1136,34 +1262,7 @@ export const TransportMessage = {
             break;
           }
 
-          message.message = { $case: "init", init: TransportInit.decode(reader, reader.uint32()) };
-          continue;
-        case 2:
-          if (tag != 18) {
-            break;
-          }
-
-          message.message = { $case: "heartbeat", heartbeat: TransportHeartbeat.decode(reader, reader.uint32()) };
-          continue;
-        case 3:
-          if (tag != 26) {
-            break;
-          }
-
-          message.message = {
-            $case: "authRequest",
-            authRequest: TransportAuthorizationRequest.decode(reader, reader.uint32()),
-          };
-          continue;
-        case 4:
-          if (tag != 34) {
-            break;
-          }
-
-          message.message = {
-            $case: "authResponse",
-            authResponse: TransportAuthorizationResponse.decode(reader, reader.uint32()),
-          };
+          message.data.push(IslandData.decode(reader, reader.uint32()));
           continue;
       }
       if ((tag & 7) == 4 || tag == 0) {
@@ -1174,71 +1273,27 @@ export const TransportMessage = {
     return message;
   },
 
-  fromJSON(object: any): TransportMessage {
-    return {
-      message: isSet(object.init)
-        ? { $case: "init", init: TransportInit.fromJSON(object.init) }
-        : isSet(object.heartbeat)
-        ? { $case: "heartbeat", heartbeat: TransportHeartbeat.fromJSON(object.heartbeat) }
-        : isSet(object.authRequest)
-        ? { $case: "authRequest", authRequest: TransportAuthorizationRequest.fromJSON(object.authRequest) }
-        : isSet(object.authResponse)
-        ? { $case: "authResponse", authResponse: TransportAuthorizationResponse.fromJSON(object.authResponse) }
-        : undefined,
-    };
+  fromJSON(object: any): IslandStatusMessage {
+    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => IslandData.fromJSON(e)) : [] };
   },
 
-  toJSON(message: TransportMessage): unknown {
+  toJSON(message: IslandStatusMessage): unknown {
     const obj: any = {};
-    message.message?.$case === "init" &&
-      (obj.init = message.message?.init ? TransportInit.toJSON(message.message?.init) : undefined);
-    message.message?.$case === "heartbeat" &&
-      (obj.heartbeat = message.message?.heartbeat ? TransportHeartbeat.toJSON(message.message?.heartbeat) : undefined);
-    message.message?.$case === "authRequest" && (obj.authRequest = message.message?.authRequest
-      ? TransportAuthorizationRequest.toJSON(message.message?.authRequest)
-      : undefined);
-    message.message?.$case === "authResponse" && (obj.authResponse = message.message?.authResponse
-      ? TransportAuthorizationResponse.toJSON(message.message?.authResponse)
-      : undefined);
+    if (message.data) {
+      obj.data = message.data.map((e) => e ? IslandData.toJSON(e) : undefined);
+    } else {
+      obj.data = [];
+    }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TransportMessage>, I>>(base?: I): TransportMessage {
-    return TransportMessage.fromPartial(base ?? {});
+  create<I extends Exact<DeepPartial<IslandStatusMessage>, I>>(base?: I): IslandStatusMessage {
+    return IslandStatusMessage.fromPartial(base ?? {});
   },
 
-  fromPartial<I extends Exact<DeepPartial<TransportMessage>, I>>(object: I): TransportMessage {
-    const message = createBaseTransportMessage();
-    if (object.message?.$case === "init" && object.message?.init !== undefined && object.message?.init !== null) {
-      message.message = { $case: "init", init: TransportInit.fromPartial(object.message.init) };
-    }
-    if (
-      object.message?.$case === "heartbeat" &&
-      object.message?.heartbeat !== undefined &&
-      object.message?.heartbeat !== null
-    ) {
-      message.message = { $case: "heartbeat", heartbeat: TransportHeartbeat.fromPartial(object.message.heartbeat) };
-    }
-    if (
-      object.message?.$case === "authRequest" &&
-      object.message?.authRequest !== undefined &&
-      object.message?.authRequest !== null
-    ) {
-      message.message = {
-        $case: "authRequest",
-        authRequest: TransportAuthorizationRequest.fromPartial(object.message.authRequest),
-      };
-    }
-    if (
-      object.message?.$case === "authResponse" &&
-      object.message?.authResponse !== undefined &&
-      object.message?.authResponse !== null
-    ) {
-      message.message = {
-        $case: "authResponse",
-        authResponse: TransportAuthorizationResponse.fromPartial(object.message.authResponse),
-      };
-    }
+  fromPartial<I extends Exact<DeepPartial<IslandStatusMessage>, I>>(object: I): IslandStatusMessage {
+    const message = createBaseIslandStatusMessage();
+    message.data = object.data?.map((e) => IslandData.fromPartial(e)) || [];
     return message;
   },
 };