yeet

modules/rpc/Constants.tsx

@@ -0,0 +1,135 @@
+// Metro module 4092 (f4093).
+const r8 = {
+  ANY: "$any",
+  ALL: "$all"
+};
+let c2355_0 = {
+  USER_SETTINGS: "USER_SETTINGS",
+  CHANGELOG: "CHANGELOG",
+  LIBRARY: "LIBRARY",
+  STORE_HOME: "STORE_HOME",
+  STORE_LISTING: "STORE_LISTING",
+  CHANNEL: "CHANNEL",
+  GAME_SHOP: "GAME_SHOP",
+  PICK_GUILD_SETTINGS: "PICK_GUILD_SETTINGS",
+  QUEST_HOME: "QUEST_HOME",
+  DISCOVERY_GAME_RESULTS: "DISCOVERY_GAME_RESULTS",
+  OAUTH2: "OAUTH2",
+  FEATURES: "FEATURES",
+  SHOP: "SHOP",
+  ACTIVITIES: "ACTIVITIES",
+  QUEST_PREVIEW_TOOL: "QUEST_PREVIEW_TOOL",
+  ONE_TIME_LOGIN: "ONE_TIME_LOGIN",
+  PLAYGROUND: "PLAYGROUND"
+};
+let c2355_1 = {
+  SETTINGS: "settings",
+  CHANGELOG: "changelog",
+  LIBRARY: "library",
+  STORE: "store",
+  INVITE: "invite",
+  CHANNEL: "channel",
+  GUILD_SETTINGS: "guild_settings",
+  QUEST_HOME: "quest_home",
+  DISCOVERY_GAME: "discovery_game",
+  SHOP: "shop",
+  ACTIVITIES: "activities",
+  QUEST_PREVIEW_TOOL: "quest_preview_tool",
+  PLAYGROUND: "playground"
+};
+const r48 = {
+  APPLICATION_NOT_FOUND: 101,
+  101: "APPLICATION_NOT_FOUND",
+  DISK_LOW: 2022,
+  2022: "DISK_LOW",
+  DISK_PERMISSION_DENIED: 2025,
+  2025: "POST_INSTALL_FAILED",
+  POST_INSTALL_FAILED: 2025,
+  REDISTRIBUTABLE_INSTALL_FAILED: 2026,
+  2026: "REDISTRIBUTABLE_INSTALL_FAILED",
+  APPLICATION_LOAD_FAILED: 2034,
+  2034: "APPLICATION_LOAD_FAILED",
+  DESERIALIZATION_FAILED: 2047,
+  2047: "DESERIALIZATION_FAILED",
+  INTERRUPTED: 2055,
+  2055: "INTERRUPTED",
+  MAX_REQUEST_RETRIES_EXCEEDED: 2058,
+  2058: "MAX_REQUEST_RETRIES_EXCEEDED",
+  AUTHENTICATION_FAILED: 2063,
+  2063: "AUTHENTICATION_FAILED",
+  IO_PERMISSION_DENIED: 2064,
+  2064: "IO_PERMISSION_DENIED",
+  NO_MANIFESTS: 2065,
+  2065: "NO_MANIFESTS",
+  POST_INSTALL_CANCELLED: 2066,
+  2066: "POST_INSTALL_CANCELLED",
+  API_ERROR: 2069,
+  2069: "API_ERROR",
+  FILE_NAME_TOO_LONG: 2072,
+  2072: "FILE_NAME_TOO_LONG",
+  NOT_ENTITLED: 2073,
+  2073: "NOT_ENTITLED",
+  APPLICATION_LOCK_FAILED: 2076,
+  2076: "APPLICATION_LOCK_FAILED",
+  NOT_DIRECTORY: 2077,
+  2077: "NOT_DIRECTORY",
+  INVALID_DRIVE: 2078,
+  2078: "INVALID_DRIVE",
+  DISK_FULL: 2080,
+  2080: "DISK_FULL"
+};
+const r87 = {
+  IPC: "ipc",
+  WEBSOCKET: "ws",
+  HTTP: "http",
+  POST_MESSAGE: "post_message"
+};
+export { r8 as RPC_SCOPE_CONFIG };
+export const RPC_PRIVATE_SCOPE = "RPC_PRIVATE_SCOPE";
+export const RPC_PRIVATE_LIMITED_SCOPE = "RPC_PRIVATE_LIMITED_SCOPE";
+export const RPC_LOCAL_SCOPE = "RPC_LOCAL_SCOPE";
+export const RPC_AUTHENTICATED_SCOPE = "RPC_AUTHENTICATED_SCOPE";
+export const RPC_EMBEDDED_APP_SCOPE = "RPC_EMBEDDED_APP_SCOPE";
+export { c2355_0 as RPCDeepLinks };
+export { c2355_1 as DynamicLinkType };
+export function getDynamicLinkType(a0) {
+  if (c2355_0.USER_SETTINGS === a0) {
+    return c2355_1.SETTINGS;
+  }
+  if (c2355_0.CHANGELOG === a0) {
+    return c2355_1.CHANGELOG;
+  }
+  if (c2355_0.LIBRARY === a0) {
+    return c2355_1.LIBRARY;
+  }
+  if (c2355_0.STORE_HOME !== a0 && c2355_0.STORE_LISTING !== a0) {
+    if (c2355_0.CHANNEL === a0) {
+      return c2355_1.CHANNEL;
+    }
+    if (c2355_0.PICK_GUILD_SETTINGS === a0) {
+      return c2355_1.GUILD_SETTINGS;
+    }
+    if (c2355_0.QUEST_HOME === a0) {
+      return c2355_1.QUEST_HOME;
+    }
+    if (c2355_0.QUEST_PREVIEW_TOOL === a0) {
+      return c2355_1.QUEST_PREVIEW_TOOL;
+    }
+    if (c2355_0.DISCOVERY_GAME_RESULTS === a0) {
+      return c2355_1.DISCOVERY_GAME;
+    }
+    if (c2355_0.SHOP === a0) {
+      return c2355_1.SHOP;
+    }
+    if (c2355_0.ACTIVITIES === a0) {
+      return c2355_1.ACTIVITIES;
+    }
+    if (c2355_0.PLAYGROUND === a0) {
+      return c2355_1.PLAYGROUND;
+    }
+    return a0;
+  }
+  return c2355_1.STORE;
+}
+export { r48 as DispatchErrorCodes };
+export { r87 as TransportTypes };

modules/rpc/RPCError.tsx

@@ -0,0 +1,3 @@
+// Metro module 10626 (f10627).
+import { RPCError } from "../../_bundle/Module10627";
+export default RPCError;

modules/rpc/RPCHelpers.tsx

@@ -0,0 +1,464 @@
+// Metro module 10631 (f10632).
+import ApplicationStore from "../applications/ApplicationStore";
+import ApplicationRecord from "../../records/ApplicationRecord";
+import { GUILD_VOCAL_CHANNEL_TYPES } from "../../records/ChannelRecord";
+import UserRecord from "../../records/UserRecord";
+import ChannelStore from "../../stores/ChannelStore";
+import GuildStore from "../../stores/GuildStore";
+import MediaEngineStore from "../../stores/MediaEngineStore";
+import MessageStore from "../../stores/MessageStore";
+import PresenceStore from "../../stores/PresenceStore";
+import UserStore from "../../stores/UserStore";
+import VoiceStateStore from "../../stores/VoiceStateStore";
+import { RPC_LOCAL_SCOPE, TransportTypes } from "./Constants";
+import { ActivityActionTypes, ChannelTypes, Endpoints, MAX_MESSAGES_PER_CHANNEL, RPCCloseCodes, RPCErrors, RTCConnectionStates } from "../../Constants";
+import URLUtils from "../../utils/URLUtils";
+import RegexUtils from "../../utils/RegexUtils";
+import Durations from "../../utils/Durations";
+import Module12 from "../../_bundle/Module12";
+import MessageActionCreators from "../../actions/MessageActionCreators";
+import MarkupUtils from "../markup/MarkupUtils";
+import { getUserAuthor } from "../messages/useMessageAuthor";
+import transformUser from "./helpers/transformUser";
+import NicknameUtils from "../../utils/NicknameUtils";
+import Url from "../../_bundle/Url_1469";
+import { OAuth2Scopes } from "../../_bundle/Module8174";
+import { HTTP } from "../../_bundle/sendRequest";
+import RPCError from "./RPCError";
+import getURLForApplication from "../activities/getURLForApplication";
+import LeakyBucket from "../../_bundle/LeakyBucket";
+function $mk107395() {
+  return (a0, a1) => a0.index - a1.index;
+}
+function $mk107396() {
+  return (a0) => ({
+    id: a0.id,
+    name: a0.name
+  });
+}
+let c7133_24, c7133_25, c7133_26, validateOrigin, transformInternalTextMessage, fetchApplicationRPC;
+const recurseReplaceContentTree = function recurseReplaceContentTree(a0) {
+  if (a0.type === "customEmoji") {
+    a0.type = "emoji";
+  }
+  if (a0.type === "emoji" && a0.src) {
+    const src = a0.src;
+    a0.src = /^http/.test(src) ? src : `${location.protocol}//${location.host}${src.charAt(0) === "/" ? "" : "/"}${src}`;
+  }
+  if (Array.isArray(a0.content)) {
+    a0.content = a0.content.map(recurseReplaceContentTree);
+  }
+  return a0;
+};
+validateOrigin = function validateOrigin(a0, r4 = []) {
+  return r4.indexOf(a0) > -1;
+};
+transformInternalTextMessage = function transformInternalTextMessage(message) {
+  const r21 = MarkupUtils.parseToAST(message.content, true, {
+    channelId: message.channel_id
+  }).map(recurseReplaceContentTree);
+  const channel = ChannelStore.getChannel(message.channel_id);
+  const r28 = message.author != null ? new UserRecord(message.author) : void 0;
+  const r33 = message.author != null ? getUserAuthor(r28, channel) : void 0;
+  return {
+    id: message.id,
+    blocked: message.blocked,
+    bot: message.bot,
+    content: message.content,
+    content_parsed: r21.length ? r21 : void 0,
+    nick: r33?.nick,
+    author_color: r33?.colorString,
+    edited_timestamp: message.edited_timestamp || message.editedTimestamp,
+    timestamp: message.timestamp,
+    tts: message.tts,
+    mentions: message.mentions,
+    mention_everyone: message.mention_everyone || message.mentionEveryone,
+    mention_roles: message.mention_roles || message.mentionRoles,
+    embeds: message.embeds,
+    attachments: message.attachments,
+    author: r28 != null ? transformUser(r28) : void 0,
+    pinned: message.pinned,
+    type: message.type
+  };
+};
+fetchApplicationRPC = function fetchApplicationRPC(a0) {
+  return HTTP.get({
+    url: Endpoints.APPLICATION_RPC(a0),
+    oldFormErrors: true,
+    retries: 3,
+    rejectWithError: true
+  }).then((result) => result.body, () => {
+    throw new RPCError({
+      closeCode: RPCCloseCodes.INVALID_CLIENTID
+    }, "Invalid Client ID");
+  });
+};
+let r76 = URLUtils.toURLSafe(window.GLOBAL_ENV.API_ENDPOINT)?.host;
+if (r76 == null) {
+  r76 = "localhost";
+}
+let r80 = r76.split(":")[0];
+const r83 = r80.includes(".");
+let r18 = r80;
+if (r83) {
+  const r85 = r80.split(".");
+  if (!/^\d+$/.test(r85[r85.length - 1])) {
+    r80 = r85.slice(-2).join(".");
+  }
+  r18 = r80;
+}
+export function getRemoteIconURL(a0) {
+  return /^http/.test(a0) ? a0 : `${location.protocol}//${location.host}${a0.charAt(0) === "/" ? "" : "/"}${a0}`;
+}
+export function transformVoiceState(a0, a1, { mute, deaf, selfMute, selfDeaf, suppress, userId }) {
+  const user = UserStore.getUser(userId);
+  if (user == null) {
+    throw new Error(`Invalid user id: ${userId}`);
+  }
+  return {
+    nick: NicknameUtils.getName(a0, a1, user),
+    mute: MediaEngineStore.isLocalMute(user.id),
+    volume: MediaEngineStore.getLocalVolume(user.id),
+    pan: MediaEngineStore.getLocalPan(user.id),
+    voice_state: {
+      mute,
+      deaf,
+      self_mute: selfMute,
+      self_deaf: selfDeaf,
+      suppress
+    },
+    user: transformUser(user)
+  };
+}
+c7133_24 = new RegExp(`^${RegexUtils.escape("https://")}(?:[a-z]+\\.)?(${RegexUtils.escape(r18)}|discordapp.com|discord.com)\$`);
+c7133_25 = 1 * Durations.Millis.MINUTE;
+c7133_26 = {};
+export const VALIDATE_SOCKET_CALLS_PER_PERIOD_LOW = 2;
+export const VALIDATE_SOCKET_CALLS_PER_PERIOD_HIGH = 60;
+export { c7133_25 as VALIDATE_SOCKET_PERIOD_MS };
+export { c7133_26 as VALIDATE_SOCKET_THROTTLERS };
+export function containsSameValues(a0, a1) {
+  return Module12.isEqual(a0, Module12.pick(a1, Object.keys(a0)));
+}
+export { validateOrigin };
+export function transformChannel(a0, c18160_1) {
+  const r11 = [];
+  const guildId = a0.getGuildId();
+  if (![ChannelTypes.GUILD_CATEGORY, ...GUILD_VOCAL_CHANNEL_TYPES].includes(a0.type)) {
+    r11.push(new Promise((c26766_0) => {
+      MessageStore.whenReady(a0.id, () => c26766_0());
+      MessageActionCreators.fetchMessages({
+        channelId: a0.id,
+        limit: MAX_MESSAGES_PER_CHANNEL
+      });
+    }));
+  }
+  return Promise.all(r11).then(() => {
+    let r4, messages;
+    L7: {
+      L5: {
+        r4 = a0;
+        if (r4.isNSFW()) {
+          if (UserStore.getCurrentUser()?.nsfwAllowed !== true) {
+            break L5;
+          }
+        }
+        if (c18160_1) {
+          messages = MessageStore.getMessages(r4.id).toArray().map(transformInternalTextMessage);
+          break L7;
+        }
+      }
+      messages = [];
+    }
+    return {
+      id: r4.id,
+      name: r4.name,
+      type: r4.type,
+      topic: r4.topic,
+      bitrate: r4.bitrate,
+      user_limit: r4.userLimit,
+      guild_id: guildId,
+      position: r4.position,
+      messages,
+      voice_states: Object.values(VoiceStateStore.getVoiceStatesForChannel(r4.id)).map((item) => {
+        const id = a0.id;
+        const { mute, deaf, selfMute, selfDeaf, suppress, userId } = item;
+        const user = UserStore.getUser(userId);
+        if (user == null) {
+          throw new Error(`Invalid user id: ${userId}`);
+        }
+        return {
+          nick: NicknameUtils.getName(guildId, id, user),
+          mute: MediaEngineStore.isLocalMute(user.id),
+          volume: MediaEngineStore.getLocalVolume(user.id),
+          pan: MediaEngineStore.getLocalPan(user.id),
+          voice_state: {
+            mute,
+            deaf,
+            self_mute: selfMute,
+            self_deaf: selfDeaf,
+            suppress
+          },
+          user: transformUser(user)
+        };
+      })
+    };
+  });
+}
+export { transformInternalTextMessage };
+export function transformBaseRelationship(a0, a1) {
+  return {
+    type: a0,
+    user: transformUser(a1),
+    presence: {
+      status: PresenceStore.getStatus(a1.id, null),
+      activity: null
+    }
+  };
+}
+export function transformApplicationRelationship(a0, a1) {
+  let r1 = a0;
+  if (a1 != null) {
+    let activity = PresenceStore.getApplicationActivity(a0.user.id, a1);
+    if (activity == null) {
+      activity = null;
+    }
+    r1 = {
+      ...a0,
+      presence: {
+        ...a0.presence,
+        activity
+      }
+    };
+  }
+  return r1;
+}
+export function isMatchingOrigin(a0) {
+  let hostname;
+  if (a0 == null) {
+    return false;
+  }
+  const origin = window.location.origin;
+  if (a0 === origin) {
+    return true;
+  }
+  try {
+    hostname = Url.parse(a0).hostname;
+  } catch ($e) {
+    return false;
+  }
+  let r20 = window.location.hostname === hostname && hostname === "localhost";
+  if (!r20) {
+    let r26 = a0.match("staging") == null;
+    if (r26) {
+      const r29 = c7133_24.test(a0);
+      r26 = !(r29 ? !c7133_24.test(origin) : !r29);
+    }
+    r20 = r26;
+  }
+  return r20;
+}
+export function hasMessageReadPermission(a0, a1, a2) {
+  const guild = GuildStore.getGuild(a0.getGuildId());
+  return (guild != null ? guild.application_id : a0.getApplicationId()) === a1 || a2.indexOf(OAuth2Scopes.MESSAGES_READ) > -1;
+}
+export function getVoiceConnectionState(a0) {
+  if (RTCConnectionStates.RTC_CONNECTED !== a0 && RTCConnectionStates.RTC_CONNECTING !== a0 && RTCConnectionStates.RTC_DISCONNECTED !== a0) {
+    return a0;
+  }
+  return a0.replace(/^RTC_/, "VOICE_");
+}
+export function validateActivityInvite(a0, a1, a2) {
+  return a0 === ActivityActionTypes.JOIN && (a1 != null && a1.id != null && a2.join != null);
+}
+export async function validateSocketApplication(c26764_0, c26764_1, c26764_2) {
+  let createFromServer, c26764_4, c26764_5;
+  let c30270_0, c30270_1, c30270_2, c30270_3, c30270_4, c30270_5, c30270_6, c30270_7, c30270_8, c30270_9, c30270_10, c30270_11;
+  L17: {
+    L24: {
+      L16: {
+        L7: {
+          c26764_5 = void 0;
+          c30270_0 = c26764_0;
+          c30270_1 = c26764_1;
+          c30270_2 = c26764_2;
+          c30270_3 = void 0;
+          c30270_4 = void 0;
+          c30270_5 = void 0;
+          c30270_6 = void 0;
+          c30270_7 = void 0;
+          c30270_8 = void 0;
+          c30270_9 = void 0;
+          c30270_10 = void 0;
+          c30270_11 = void 0;
+          c30270_3 = ApplicationStore.getApplication(c26764_1);
+          if (typeof c26764_2 === "string") {
+            if (c26764_0.transport === TransportTypes.POST_MESSAGE) {
+              const uRLForApplication = getURLForApplication(c26764_1);
+              if (uRLForApplication != null && validateOrigin(c26764_2, [uRLForApplication])) {
+                break L7;
+              }
+              throw new RPCError({
+                closeCode: RPCCloseCodes.INVALID_ORIGIN
+              }, "Invalid Origin");
+            }
+            c30270_4 = await fetchApplicationRPC(c26764_1);
+            c30270_3 = ApplicationRecord.createFromServer(c30270_4);
+            if ((0, validateOrigin)(c30270_2, c30270_4.rpc_origins)) {
+              if (c30270_3 == null) {
+                c26764_4 = ApplicationRecord;
+                createFromServer = ApplicationRecord.createFromServer;
+                c30270_3 = createFromServer.call(c26764_4, await (0, fetchApplicationRPC)(c30270_1));
+                break L16;
+              }
+              break L16;
+            }
+            throw new RPCError({
+              closeCode: RPCCloseCodes.INVALID_ORIGIN
+            }, "Invalid Origin");
+          }
+        }
+        if (c30270_3 != null) {
+          c30270_5 = c30270_3;
+          c30270_6 = c30270_5.id;
+          c30270_7 = c30270_5.name;
+          c30270_8 = c30270_5.icon;
+          c30270_9 = c30270_5.coverImage;
+          c30270_10 = c30270_5.flags;
+          c30270_11 = c30270_5.parentId;
+          c30270_0.application = {
+            id: c30270_6,
+            parentId: c30270_11,
+            name: c30270_7,
+            icon: c30270_8,
+            coverImage: c30270_9,
+            flags: c30270_10
+          };
+          break L24;
+        }
+        c26764_4 = ApplicationRecord;
+        createFromServer = ApplicationRecord.createFromServer;
+        c30270_3 = createFromServer.call(c26764_4, await (0, fetchApplicationRPC)(c30270_1));
+      }
+      c30270_5 = c30270_3;
+      c30270_6 = c30270_5.id;
+      c30270_7 = c30270_5.name;
+      c30270_8 = c30270_5.icon;
+      c30270_9 = c30270_5.coverImage;
+      c30270_10 = c30270_5.flags;
+      c30270_11 = c30270_5.parentId;
+      c30270_0.application = {
+        id: c30270_6,
+        parentId: c30270_11,
+        name: c30270_7,
+        icon: c30270_8,
+        coverImage: c30270_9,
+        flags: c30270_10
+      };
+      break L17;
+    }
+    return void 0;
+  }
+}
+export async function processSocketThrottlers(c26765_0, c26765_1, c26765_2) {
+  let c26765_6 = 0;
+  try {
+    let r17 = c7133_26[c26765_0];
+    if (r17 == null) {
+      const r23 = 60;
+      if (!c26765_1) {
+        const leakyBucket = new LeakyBucket(r23, c7133_25);
+        c7133_26[c26765_0] = leakyBucket;
+        r17 = leakyBucket;
+      } else {
+        const leakyBucket2 = new LeakyBucket(2, c7133_25);
+        c7133_26[c26765_0] = leakyBucket2;
+        r17 = leakyBucket2;
+      }
+    }
+    c26765_6 = 1;
+    await r17.process(c26765_2);
+    c26765_6 = 0;
+  } catch ($e) {
+    let r8 = $e;
+    if (c26765_6 !== 0) {
+      while (true) {
+        try {
+          c26765_6 = 0;
+          throw new RPCError({
+            closeCode: RPCCloseCodes.CLOSE_ABNORMAL
+          }, "Socket closed during throttle");
+        } catch ($e) {
+          r8 = $e;
+          if (c26765_6 === 0) {
+            break;
+          }
+        }
+      }
+    }
+    throw r8;
+  }
+}
+export function validateOriginAndUpdateSocket(a0, a1) {
+  if (a1 == null) {
+    a0.authorization.scopes = [RPC_LOCAL_SCOPE];
+  }
+}
+export function getDeprecatedVoiceSettingsWithShortcut(a0) {
+  const settings = MediaEngineStore.getSettings();
+  const shortcut = a0(settings);
+  return {
+    input: {
+      available_devices: Object.values(MediaEngineStore.getInputDevices()).sort($mk107395()).map($mk107396()),
+      device_id: settings.inputDeviceId,
+      volume: settings.inputVolume
+    },
+    output: {
+      available_devices: Object.values(MediaEngineStore.getOutputDevices()).sort($mk107395()).map($mk107396()),
+      device_id: settings.outputDeviceId,
+      volume: settings.outputVolume
+    },
+    mode: {
+      type: settings.mode,
+      auto_threshold: settings.modeOptions.autoThreshold,
+      threshold: settings.modeOptions.threshold,
+      shortcut,
+      delay: settings.modeOptions.delay
+    },
+    automatic_gain_control: settings.automaticGainControl,
+    echo_cancellation: settings.echoCancellation,
+    noise_suppression: settings.noiseSuppression,
+    qos: settings.qos,
+    silence_warning: settings.silenceWarning,
+    deaf: settings.deaf,
+    mute: settings.mute
+  };
+}
+export function getVoiceSettingsWithShortcut(a0, a1) {
+  const settings = MediaEngineStore.getSettings(a0);
+  return {
+    input_mode: {
+      type: settings.mode,
+      shortcut: a1(settings)
+    },
+    local_mutes: Object.keys(settings.localMutes),
+    local_volumes: settings.localVolumes,
+    self_mute: settings.mute,
+    self_deaf: settings.deaf
+  };
+}
+export function validatePostMessageTransport(a0) {
+  if (a0 !== TransportTypes.POST_MESSAGE) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, `command not available from "${a0} transport`);
+  }
+}
+export function validateApplication(a0) {
+  if (a0.id == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, "Invalid application");
+  }
+  return a0.id;
+}

modules/rpc/RPCOpcodes.tsx

@@ -0,0 +1,7 @@
+// Metro module 10625 (f10626).
+export default {
+  HANDSHAKE: 0,
+  FRAME: 1,
+  CLOSE: 2,
+  HELLO: 3
+};

modules/rpc/RPCServer.tsx

@@ -0,0 +1,327 @@
+// Metro module 13581 (f13582).
+import { TransportTypes } from "./Constants";
+import { RPCErrors, RPCCloseCodes, RPCCommands, RPCEvents, AnalyticEvents } from "../../Constants";
+import Module12 from "../../_bundle/Module12";
+import transformUser from "./helpers/transformUser";
+import RPCError from "./RPCError";
+import validateScope from "./helpers/validateScope";
+import AnalyticsUtils from "../../utils/AnalyticsUtils";
+import Module38 from "../../_bundle/Module38";
+import Durations from "../../utils/Durations";
+function $mk118910($env) {
+  return (a0) => {
+    const r1 = $env;
+    if (a0 == null) {
+      (0, r1[0])($env.$parent[0]);
+    } else {
+      const r3 = r1[1];
+      r3(new RPCError({
+        errorCode: RPCErrors.INVALID_PAYLOAD
+      }, a0.message));
+    }
+  };
+}
+let env9435 = {};
+const c9435_9 = "RPC_STORE_WAIT";
+const c9435_10 = [];
+class RPCServer {
+  constructor(a0) {
+    const r7 = {
+      __proto__: new.target.prototype,
+      getCurrentUser: () => null,
+      onConnect: null,
+      onDisconnect: null,
+      events: null,
+      commands: null,
+      sockets: null,
+      subscriptions: null,
+      isSubscribedListeners: null
+    };
+    r7.onConnect = () => {};
+    r7.onDisconnect = () => {};
+    r7.events = {};
+    r7.commands = {};
+    r7.sockets = new Set();
+    r7.subscriptions = [];
+    r7.isSubscribedListeners = new Set();
+    r7.getJoi = a0;
+    return r7;
+  }
+  registerTransport(a0) {
+    a0.on("connect", (a0) => this.handleConnect(a0));
+    a0.on("request", (a0, a1) => this.handleRequest(a0, a1));
+    a0.on("disconnect", (a0, a1) => this.handleDisconnect(a0, a1));
+  }
+  handleConnect(a0) {
+    this.sockets.add(a0);
+    this.onConnect(a0);
+    const r6 = {
+      v: a0.version,
+      config: {
+        cdn_host: window.GLOBAL_ENV.CDN_HOST,
+        api_endpoint: window.GLOBAL_ENV.API_ENDPOINT,
+        environment: "production"
+      }
+    };
+    if (a0.transport === TransportTypes.IPC) {
+      const currentUser = this.getCurrentUser();
+      if (currentUser == null) {
+        a0.close(RPCCloseCodes.CLOSE_NORMAL, "User logged out");
+        return void 0;
+      }
+      r6.user = transformUser(currentUser);
+    }
+    this.dispatch(a0, null, RPCCommands.DISPATCH, RPCEvents.READY, r6);
+  }
+  handleDisconnect(a0, a1) {
+    a0.abortController.abort("DISCONNECTED");
+    this.removeSubscriptions(a0);
+    this.sockets.delete(a0);
+    this.onDisconnect(a0, a1);
+  }
+  handleRequest(a0, a1) {
+    let env20547 = {
+      $parent: env9435
+    };
+    env20547[3] = this;
+    env20547[1] = a0;
+    env20547[2] = a1;
+    env20547[0] = this;
+    new Promise((resolve) => {
+      const r1 = env20547[2];
+      if (r1.nonce != null && r1.nonce !== "") {
+        const cmd = r1.cmd;
+        const r19 = env20547[3].commands[cmd];
+        if (r19 == null) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_COMMAND
+          }, `Invalid command: ${r1.cmd}`);
+        }
+        const r8 = env20547[1];
+        if (validateScope(r8.authorization.scopes, r19.scope)) {
+          AnalyticsUtils.track(AnalyticEvents.RPC_COMMAND_SENT, {
+            command: cmd,
+            scope: typeof r19.scope === "object" ? JSON.stringify(r19.scope) : r19.scope,
+            application_id: r8.application.id,
+            socket_scope: r8.authorization.scopes.toString()
+          });
+          resolve(r19);
+          return void 0;
+        }
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_PERMISSIONS
+        }, "Not authenticated or invalid scope");
+      }
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_PAYLOAD
+      }, "Payload requires a nonce");
+    }).then((result) => {
+      let env27523 = {
+        $parent: env20547
+      };
+      env27523[0] = result;
+      const r3 = Promise;
+      let c27524_0 = async (c31693_0, c31693_1) => {
+        let c31693_2, c31693_3;
+        L14: {
+          let env32050;
+          c31693_3 = void 0;
+          const r12 = env32050 = {
+            $parent: env27523
+          };
+          c31693_2 = r12;
+          env32050[0] = c31693_0;
+          env32050[1] = c31693_1;
+          env32050[2] = void 0;
+          if (env27523[0].validation != null) {
+            const joi = await env20547[0].getJoi();
+            const r51 = c31693_2;
+            env32050[2] = joi;
+            Module38(env27523[0].validation != null, "command.validation must not be null");
+            env32050[2].validate(env20547[2].args, env27523[0].validation(env32050[2]), {
+              convert: false
+            }, $mk118910(r51));
+            break L14;
+          }
+          c31693_0(env27523[0]);
+          return void 0;
+        }
+      };
+      return new r3(function() {
+        return c27524_0.apply(this, arguments);
+      });
+    }).then((result) => {
+      const handler = result.handler;
+      const socket = env20547[1];
+      const r8 = env20547[2];
+      let args = r8.args;
+      if (args == null) {
+        args = {};
+      }
+      return handler.call(result, {
+        socket,
+        server: env20547[3],
+        cmd: r8.cmd,
+        evt: r8.evt,
+        nonce: r8.nonce,
+        args,
+        isSocketConnected: () => env20547[3].sockets.has(env20547[1]),
+        signal: socket.abortController.signal
+      });
+    }).then((result) => {
+      const r6 = env20547[3];
+      const r11 = env20547[1];
+      const r13 = env20547[2];
+      return r6.dispatch(r11, r13.nonce, r13.cmd, null, result);
+    }).catch(({ code, message }) => {
+      const r4 = env20547[3];
+      const r11 = env20547[1];
+      const r13 = env20547[2];
+      return r4.error(r11, r13.nonce, r13.cmd, code, message);
+    });
+  }
+  setCommandHandler(a0, a1) {
+    this.commands[a0] = a1;
+  }
+  setEventHandler(a0, a1) {
+    this.events[a0] = a1;
+  }
+  dispatch(a0, nonce = null, cmd = RPCCommands.DISPATCH, evt = null, data = null) {
+    a0.send({
+      cmd,
+      data,
+      evt,
+      nonce
+    });
+  }
+  error(a0, r8 = null, command = RPCCommands.DISPATCH, code = RPCErrors.UNKNOWN_ERROR, message = "Unknown Error") {
+    AnalyticsUtils.track(AnalyticEvents.RPC_SERVER_ERROR_CAUGHT, {
+      command,
+      code,
+      message
+    });
+    this.dispatch(a0, r8, command, RPCEvents.ERROR, {
+      code,
+      message
+    });
+  }
+  listenIsSubscribed(a0) {
+    this.isSubscribedListeners.add(a0);
+    return () => {
+      this.isSubscribedListeners.delete(a0);
+    };
+  }
+  dispatchIsSubscribedUpdate() {
+    this.isSubscribedListeners.forEach((isSubscribedListener) => isSubscribedListener());
+  }
+  isSubscribed(c20549_0, c20549_1) {
+    return this.subscriptions.find((subscription) => subscription.socket.application.id === c20549_0 && subscription.evt === c20549_1) !== void 0;
+  }
+  isChildSubscribed(a0, c20550_1) {
+    return a0 != null && this.subscriptions.find((subscription) => subscription.socket.application.parentId === a0 && subscription.evt === c20550_1) !== void 0;
+  }
+  getSubscription(c20551_0, c20551_1, c20551_2) {
+    return this.subscriptions.find((subscription) => subscription.socket === c20551_0 && subscription.evt === c20551_1 && Module12.isEqual(subscription.args, c20551_2));
+  }
+  addSubscription(a0, a1, a2, update = null) {
+    const dispatch2 = this.dispatch.bind(this, a0, null, RPCCommands.DISPATCH, a1);
+    if (this.getSubscription(a0, a1, a2) == null) {
+      this.subscriptions.push({
+        update,
+        dispatch: dispatch2,
+        prevState: update ? update({
+          prevState: null,
+          dispatch: dispatch2
+        }) : null,
+        socket: a0,
+        evt: a1,
+        args: a2
+      });
+      this.dispatchIsSubscribedUpdate();
+    }
+  }
+  removeSubscription(c20552_0, c20552_1, c20552_2) {
+    Module12.remove(this.subscriptions, (a0) => a0.socket === c20552_0 && a0.evt === c20552_1 && Module12.isEqual(a0.args, c20552_2));
+    this.dispatchIsSubscribedUpdate();
+  }
+  removeSubscriptions(c20553_0) {
+    Module12.remove(this.subscriptions, (a0) => a0.socket === c20553_0);
+    this.dispatchIsSubscribedUpdate();
+  }
+  dispatchToSubscriptions(c20554_1, c20554_2, c20554_0, a3) {
+    let r11 = a3 != null && a3 !== "";
+    if (r11) {
+      let r16 = !!c9435_10.includes(a3);
+      if (!r16) {
+        c9435_10.unshift(a3);
+        c9435_10.splice(50);
+        r16 = false;
+      }
+      r11 = r16;
+    }
+    if (!r11) {
+      this.subscriptions.forEach((subscription) => {
+        if (subscription.evt === c20554_1) {
+          let r0 = typeof c20554_2 === "function" ? !c20554_2(subscription) : typeof c20554_2 === "function";
+          if (!r0) {
+            let r20 = typeof c20554_2 === "object";
+            if (typeof c20554_2 === "object") {
+              let args = subscription.args;
+              if (args == null) {
+                args = {};
+              }
+              r20 = !Module12.isEqual(c20554_2, Module12.pick(args, Object.keys(c20554_2)));
+            }
+            r0 = r20;
+          }
+          if (!r0) {
+            const r33 = c20554_0;
+            if (typeof r33 === "function") {
+              c20554_0 = r33(subscription);
+            }
+            this.dispatch(subscription.socket, null, RPCCommands.DISPATCH, subscription.evt, c20554_0);
+          }
+        }
+      });
+    }
+  }
+  updateSubscriptions() {
+    this.subscriptions.forEach((subscription) => {
+      if (subscription.update) {
+        subscription.prevState = subscription.update(subscription);
+      }
+    });
+  }
+  storeWait(c20555_1, a1, a2) {
+    let removeSubscription2, uniqueId;
+    const r11 = a1();
+    if (!r11 && a2 !== 0) {
+      uniqueId = Module12.uniqueId();
+      removeSubscription2 = () => {};
+      return new Promise((c27525_0, c27525_1) => {
+        let c27525_2 = setTimeout(() => {
+          this.removeSubscription(c20555_1, c9435_9, {
+            uniqueId
+          });
+          c27525_1(new Error("timeout"));
+        }, a2 * Durations.Millis.SECOND);
+        this.addSubscription(c20555_1, c9435_9, {
+          uniqueId
+        }, () => {
+          const r2 = a1();
+          if (r2) {
+            clearTimeout(c27525_2);
+            c27525_0(r2);
+          }
+        });
+      }).then((result) => {
+        this.removeSubscription(c20555_1, c9435_9, {
+          uniqueId
+        });
+        return result;
+      });
+    }
+    return Promise.resolve(r11);
+  }
+}
+export default RPCServer;

modules/rpc/helpers/activityInstanceConnectedParticipants.tsx

@@ -0,0 +1,78 @@
+// Metro module 13523 (f13524).
+import EmbeddedActivitiesStore from "../../activities/EmbeddedActivitiesStore";
+import "../../../stores/UserStore";
+import * as _Constants from "../Constants";
+import { getEmbeddedActivityLocationGuildId, getEmbeddedActivityLocationChannelId } from "../../activities/utils/embeddedActivityLocationUtils";
+import { isNotNullish } from "../../../utils/GlobalUtils";
+import Module12 from "../../../_bundle/Module12";
+function $mk91465($env) {
+  return (a0) => {
+    const r6 = $env.$parent;
+    const user = r6[4].getUser(a0);
+    if (user != null) {
+      const r12 = $env;
+      const r7 = r6[0];
+      const r13 = r6[2];
+      let nickname = r7(r13[4]).getNickname(r12[0], r12[1], user);
+      const r20 = {
+        ...(0, r6[1])(r13[5])(user)
+      };
+      if (nickname == null) {
+        nickname = void 0;
+      }
+      r20.nickname = nickname;
+      return r20;
+    }
+  };
+}
+let env9386 = {};
+const { RPC_AUTHENTICATED_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE];
+const r24 = {
+  scope,
+  handler: () => ({ prevState, dispatch: dispatch2 }) => {
+    let r33;
+    let env27495;
+    const r7 = env27495 = {
+      $parent: env9386
+    };
+    env27495[0] = void 0;
+    env27495[1] = void 0;
+    const currentEmbeddedActivity = EmbeddedActivitiesStore.getCurrentEmbeddedActivity();
+    if (currentEmbeddedActivity == null) {
+      r33 = {
+        participants: []
+      };
+    } else {
+      env27495[0] = getEmbeddedActivityLocationGuildId(currentEmbeddedActivity.location);
+      env27495[1] = getEmbeddedActivityLocationChannelId(currentEmbeddedActivity.location);
+      r33 = {
+        participants: Array.from(currentEmbeddedActivity.userIds, $mk91465(r7)).filter(isNotNullish)
+      };
+    }
+    if (!Module12.isEqual(r33, prevState)) {
+      dispatch2(r33);
+    }
+    return r33;
+  }
+};
+export function activityInstanceConnectedParticipants() {
+  const currentEmbeddedActivity = EmbeddedActivitiesStore.getCurrentEmbeddedActivity();
+  if (currentEmbeddedActivity == null) {
+    return {
+      participants: []
+    };
+  }
+  let env20512;
+  const r8 = env20512 = {
+    $parent: env9386
+  };
+  env20512[0] = getEmbeddedActivityLocationGuildId(currentEmbeddedActivity.location);
+  env20512[1] = getEmbeddedActivityLocationChannelId(currentEmbeddedActivity.location);
+  return {
+    participants: Array.from(currentEmbeddedActivity.userIds, $mk91465(r8)).filter(isNotNullish)
+  };
+}
+export { scope as activityInstanceConnectedParticipantsScope };
+export { r24 as activityInstanceConnectedParticipantsUpdateEvent };

modules/rpc/helpers/createRpcJoiSchemaObject.tsx

@@ -0,0 +1,4 @@
+// Metro module 10629 (f10630).
+export default function createRpcJoiSchemaObject(a0) {
+  return a0.object().unknown(true);
+};

modules/rpc/helpers/getCurrentEmbeddedActivityChannel.tsx

@@ -0,0 +1,6 @@
+// Metro module 13527 (f13528).
+import EmbeddedActivitiesStore from "../../activities/EmbeddedActivitiesStore";
+import ChannelStore from "../../../stores/ChannelStore";
+export default function getCurrentEmbeddedActivityChannel() {
+  return ChannelStore.getChannel(EmbeddedActivitiesStore.getConnectedActivityChannelId());
+};

modules/rpc/helpers/getCurrentVoiceChannel.tsx

@@ -0,0 +1,7 @@
+// Metro module 10781 (f10782).
+import AuthenticationStore from "../../../stores/AuthenticationStore";
+import ChannelStore from "../../../stores/ChannelStore";
+import VoiceStateStore from "../../../stores/VoiceStateStore";
+export default function getCurrentVoiceChannel() {
+  return ChannelStore.getChannel(VoiceStateStore.getVoiceStateForSession(AuthenticationStore.getId(), AuthenticationStore.getSessionId())?.channelId);
+};

modules/rpc/helpers/stripSensitiveLoggingData.tsx

@@ -0,0 +1,39 @@
+// Metro module 10623 (f10624).
+import { RPCCommands } from "../../../Constants";
+const access_token = "<removed>";
+export default function stripSensitiveLoggingData(a0) {
+  const r5 = {
+    ...a0
+  };
+  const args = r5.args;
+  const r0 = typeof args === "object" ? typeof r5.cmd === "string" : typeof args === "object";
+  let r7 = r5;
+  if (r0) {
+    const cmd = r5.cmd;
+    r7 = RPCCommands.AUTHENTICATE !== cmd && RPCCommands.GET_PROVIDER_ACCESS_TOKEN !== cmd ? {
+      ...r5
+    } : {
+      ...r5,
+      args: {
+        ...r5.args,
+        access_token
+      }
+    };
+  }
+  const data = r7.data;
+  const r28 = typeof data === "object" ? typeof r7.cmd === "string" : typeof data === "object";
+  let r30 = r7;
+  if (r28) {
+    const cmd2 = r7.cmd;
+    r30 = RPCCommands.AUTHENTICATE !== cmd2 && RPCCommands.GET_PROVIDER_ACCESS_TOKEN !== cmd2 ? {
+      ...r7
+    } : {
+      ...r7,
+      data: {
+        ...r7.data,
+        access_token
+      }
+    };
+  }
+  return r30;
+};

modules/rpc/helpers/transformApplication.tsx

@@ -0,0 +1,10 @@
+// Metro module 13577 (f13578).
+export default function transformApplication(a0) {
+  return {
+    name: a0.name,
+    id: a0.id,
+    icon: a0.icon,
+    cover_image: a0.coverImage,
+    type: a0.type
+  };
+};

modules/rpc/helpers/transformGuildMember.tsx

@@ -0,0 +1,15 @@
+// Metro module 13576 (f13577).
+import { parseAvatarDecorationData } from "../../collectibles/avatar_decorations/AvatarDecorationUtils";
+export default function transformGuildMember({ userId, nick, guildId, avatar, avatarDecoration, banner, bio, pronouns, colorString }) {
+  return {
+    user_id: userId,
+    nick,
+    guild_id: guildId,
+    avatar,
+    avatar_decoration_data: parseAvatarDecorationData(avatarDecoration),
+    banner,
+    bio,
+    pronouns,
+    color_string: colorString
+  };
+};

modules/rpc/helpers/transformUser.tsx

@@ -0,0 +1,22 @@
+// Metro module 10632 (f10633).
+import { parseAvatarDecorationData } from "../../collectibles/avatar_decorations/AvatarDecorationUtils";
+export default function transformUser(a0) {
+  const { id, username, discriminator, globalName, avatar, avatarDecoration, bot, flags } = a0;
+  let premiumType = a0.premiumType;
+  const r13 = {
+    id,
+    username,
+    discriminator,
+    global_name: globalName,
+    avatar,
+    avatar_decoration_data: parseAvatarDecorationData(avatarDecoration),
+    bot,
+    flags,
+    premium_type: null
+  };
+  if (premiumType == null) {
+    premiumType = 0;
+  }
+  r13.premium_type = premiumType;
+  return r13;
+};

modules/rpc/helpers/unavailableCommand.tsx

@@ -0,0 +1,19 @@
+// Metro module 13574 (f13575).
+import { RPCErrors } from "../../../Constants";
+import RPCError from "../RPCError";
+const r16 = {
+  handler: (a0) => {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, `Unsupported command: ${a0.cmd}`);
+  }
+};
+const r18 = {
+  handler: (a0) => {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, `Deprecated command: ${a0.cmd}`);
+  }
+};
+export { r16 as unsupportedCommand };
+export { r18 as deprecatedCommand };

modules/rpc/helpers/validateOpenInviteDialog.tsx

@@ -0,0 +1,40 @@
+// Metro module 13538 (f13539).
+import FramesStore from "../../frames/FramesStore";
+import GuildStore from "../../../stores/GuildStore";
+import PermissionStore from "../../../stores/PermissionStore";
+import { RPCErrors } from "../../../Constants";
+import getCurrentEmbeddedActivityChannel from "./getCurrentEmbeddedActivityChannel";
+import RPCError from "../RPCError";
+import { canViewInviteModal } from "../../instant_invite/canViewInviteModal";
+export function validateOpenInviteDialog() {
+  const connectedFrame = FramesStore.getConnectedFrame();
+  if (connectedFrame != null) {
+    return {
+      frame: connectedFrame,
+      channel: void 0,
+      guild: void 0
+    };
+  }
+  const currentEmbeddedActivityChannel = getCurrentEmbeddedActivityChannel();
+  if (currentEmbeddedActivityChannel == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_CHANNEL
+    }, "Invalid channel");
+  }
+  const guild = GuildStore.getGuild(currentEmbeddedActivityChannel.getGuildId());
+  if (guild == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_CHANNEL
+    }, `Invalid guild ${currentEmbeddedActivityChannel.getGuildId()}`);
+  }
+  if (canViewInviteModal(PermissionStore, guild, currentEmbeddedActivityChannel)) {
+    return {
+      frame: void 0,
+      channel: currentEmbeddedActivityChannel,
+      guild
+    };
+  }
+  throw new RPCError({
+    errorCode: RPCErrors.INVALID_PERMISSIONS
+  }, `No invite permissions for ${currentEmbeddedActivityChannel.id}`);
+}

modules/rpc/helpers/validateScope.tsx

@@ -0,0 +1,23 @@
+// Metro module 13559 (f13560).
+import { RPC_SCOPE_CONFIG } from "../Constants";
+export default function validateScope(a0, a1) {
+  if (a1 == null) {
+    return true;
+  }
+  if (typeof a1 === "string") {
+    return a0.includes(a1);
+  }
+  if (typeof a1 !== "object") {
+    return false;
+  }
+  const r10 = a1[RPC_SCOPE_CONFIG.ANY];
+  const r13 = a1[RPC_SCOPE_CONFIG.ALL];
+  const isArray = Array.isArray(r10);
+  const r0 = isArray ? !r10.some((item) => a0.includes(item)) : !isArray;
+  let r19 = !r0;
+  if (r0) {
+    const isArray2 = Array.isArray(r13);
+    r19 = !(isArray2 ? !r13.every((item) => a0.includes(item)) : !isArray2);
+  }
+  return r19;
+};

modules/rpc/helpers/validateTransportType.tsx

@@ -0,0 +1,11 @@
+// Metro module 13553 (f13554).
+import { TransportTypes } from "../Constants";
+import { RPCErrors } from "../../../Constants";
+import RPCError from "../RPCError";
+export function validateTransportType(a0) {
+  if (TransportTypes.IPC !== a0 && TransportTypes.POST_MESSAGE !== a0) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, "Invalid transport.");
+  }
+}

modules/rpc/native/NativeRPCImplementation.tsx

@@ -0,0 +1,28 @@
+// Metro module 13524 (f13525).
+import { crossPlatformCommands } from "../server/commands/crossPlatformRPCCommands";
+import activities from "./server/commands/activities";
+import auth from "./server/commands/auth";
+import voiceSettings from "./server/commands/voiceSettings";
+import unsupported from "./server/commands/unsupported";
+import crossPlatformRPCEventHandlers from "../server/events/crossPlatformRPCEventHandlers";
+import { voiceSettingsEventHandlers } from "./events/voiceSettingsEventHandlers";
+import NativeRPCServer from "./NativeRPCServer";
+import WebViewPostMessageTransport from "./server/transports/WebViewPostMessageTransport";
+const r46 = {
+  server: NativeRPCServer,
+  commands: {
+    ...crossPlatformCommands,
+    ...activities,
+    ...auth,
+    ...voiceSettings,
+    ...unsupported
+  },
+  events: {
+    ...crossPlatformRPCEventHandlers,
+    ...voiceSettingsEventHandlers
+  },
+  stores: [],
+  transports: [WebViewPostMessageTransport],
+  registerTransportsForEmbeddedPlatform: () => {}
+};
+export default r46;

modules/rpc/native/NativeRPCServer.tsx

@@ -0,0 +1,5 @@
+// Metro module 13580 (f13581).
+import * as _Module10628 from "../../../_bundle/Module10628";
+import RPCServer from "../RPCServer";
+const rPCServer = new RPCServer(() => Promise.resolve(_Module10628));
+export default rPCServer;

modules/rpc/native/SocialRpcNetworkConfigManager.tsx

@@ -0,0 +1,31 @@
+// Metro module 16661 (f16662).
+import { NativeModules } from "react-native";
+import LocaleStore from "../../user_settings/LocaleStore";
+import AuthenticationStore from "../../../stores/AuthenticationStore";
+import AnalyticsUtils from "../../../utils/AnalyticsUtils";
+import { getAPIBaseURL } from "../../../_bundle/sendRequest";
+import AutomaticLifecycleManager from "../../../lib/AutomaticLifecycleManager";
+import { isAndroid } from "../../../utils/PlatformUtils";
+const updateSocialRpcNetworkConfig = function updateSocialRpcNetworkConfig() {
+  const headers = {
+    "X-Super-Properties": AnalyticsUtils.getSuperPropertiesBase64(),
+    "X-Fingerprint": AuthenticationStore.getFingerprint(),
+    "X-Installation-ID": AuthenticationStore.getInstallationForTracking(),
+    "X-Discord-Locale": LocaleStore.locale
+  };
+  const NativeCacheModule = NativeModules.NativeCacheModule;
+  if (NativeCacheModule != null) {
+    NativeCacheModule.setItem("socialRpcNetworkRequest", JSON.stringify({
+      apiBaseUrl: getAPIBaseURL(),
+      headers
+    }));
+  }
+};
+class SocialRpcNetworkConfigManager extends AutomaticLifecycleManager {
+  handleUpdate = isAndroid() ? updateSocialRpcNetworkConfig : () => {};
+  actions = {
+    POST_CONNECTION_OPEN: this.handleUpdate
+  };
+}
+const socialRpcNetworkConfigManager = new SocialRpcNetworkConfigManager();
+export default socialRpcNetworkConfigManager;

modules/rpc/native/events/voiceSettingsEventHandlers.tsx

@@ -0,0 +1,5 @@
+// Metro module 13578 (f13579).
+import VoiceSettingsEventsFactory from "../../server/events/VoiceSettingsEventsFactory";
+import { getDeprecatedVoiceSettings, getVoiceSettings } from "../server/NativeRPCHelpers";
+const r19 = VoiceSettingsEventsFactory(getDeprecatedVoiceSettings, getVoiceSettings);
+export { r19 as voiceSettingsEventHandlers };

modules/rpc/native/server/NativeRPCHelpers.tsx

@@ -0,0 +1,33 @@
+// Metro module 10630 (f10631).
+import { TransportTypes } from "../../Constants";
+import { RPCCloseCodes } from "../../../../Constants";
+import { validateOriginAndUpdateSocket, processSocketThrottlers, validateSocketApplication, getDeprecatedVoiceSettingsWithShortcut, getVoiceSettingsWithShortcut } from "../../RPCHelpers";
+import RPCError from "../../RPCError";
+let env7131 = {};
+let c7132_0 = async (c26763_0, c26763_1, c26763_2) => {
+  let r49;
+  let c26763_4;
+  let c30269_0, c30269_1, c30269_2;
+  L12: {
+    c26763_4 = void 0;
+    c30269_0 = c26763_0;
+    c30269_1 = c26763_1;
+    c30269_2 = c26763_2;
+    validateOriginAndUpdateSocket(c26763_0, c26763_1);
+    if (c26763_2 == null) {
+      r49 = Promise.reject(new RPCError({
+        closeCode: RPCCloseCodes.INVALID_CLIENTID
+      }, "No Client ID Specified"));
+      break L12;
+    }
+    await processSocketThrottlers(c26763_2, c26763_0.transport !== TransportTypes.POST_MESSAGE, c26763_0.abortController.signal);
+    return validateSocketApplication(c30269_0, c30269_2, c30269_1);
+  }
+  return r49;
+};
+export const validateSocketClient = function() {
+  const apply = c7132_0.apply;
+  return c7132_0.apply(this, arguments);
+};
+export const getDeprecatedVoiceSettings = () => getDeprecatedVoiceSettingsWithShortcut(() => []);
+export const getVoiceSettings = (a0) => getVoiceSettingsWithShortcut(a0, () => "");

modules/rpc/native/server/NativeRPCServerManager.tsx

@@ -0,0 +1,5 @@
+// Metro module 13521 (f13522).
+import RPCServerManager from "../../server/RPCServerManager";
+import NativeRPCImplementation from "../NativeRPCImplementation";
+const rPCServerManager = new RPCServerManager(NativeRPCImplementation);
+export default rPCServerManager;

modules/rpc/native/server/commands/activities.tsx

@@ -0,0 +1,112 @@
+// Metro module 13569 (f13570).
+import * as _Constants from "../../../Constants";
+import { RPCCommands, RPCErrors, InstantInviteSources } from "../../../../../Constants";
+import { NativePermissionTypes } from "../../../../native_permissions/NativePermissionConstants";
+import { OAuth2Scopes } from "../../../../../_bundle/Module8174";
+import { validateOpenInviteDialog } from "../../../helpers/validateOpenInviteDialog";
+import RPCError from "../../../RPCError";
+import { showInstantInviteActionSheet } from "../../../../instant_invite/native/InstantInviteUtils";
+import getCurrentEmbeddedActivityChannel from "../../../helpers/getCurrentEmbeddedActivityChannel";
+import NativePermissionUtils from "../../../../native_permissions/NativePermissionUtils";
+import ImagePicker from "../../../../image/native/ImagePicker";
+import { uploadImageAttachment } from "../../../../activities/EmbeddedActivitiesActionCreators";
+import APIError from "../../../../../errors/APIError";
+let env9426 = {};
+const { RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const r31 = {};
+const OPEN_INVITE_DIALOG = RPCCommands.OPEN_INVITE_DIALOG;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE, RPC_AUTHENTICATED_SCOPE];
+r31[OPEN_INVITE_DIALOG] = {
+  scope,
+  handler: ({ socket: socket2 }) => {
+    const r15 = validateOpenInviteDialog();
+    const channel = r15.channel;
+    if (r15.frame != null) {
+      throw new RPCError({
+        errorCode: RPCErrors.UNKNOWN_ERROR
+      }, "Cannot support frames (yet)");
+    }
+    let id = socket2.application.id;
+    if (id == null) {
+      id = void 0;
+    }
+    showInstantInviteActionSheet(channel, {
+      source: InstantInviteSources.ACTIVITY_INVITE,
+      targetApplicationId: id
+    });
+  }
+};
+const INITIATE_IMAGE_UPLOAD = RPCCommands.INITIATE_IMAGE_UPLOAD;
+const scope2 = {};
+scope2[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE, RPC_AUTHENTICATED_SCOPE];
+r31[INITIATE_IMAGE_UPLOAD] = {
+  scope: scope2,
+  handler: async ({ socket }) => {
+    let r216;
+    let c27514_0, c27514_1;
+    L27: {
+      let env30648;
+      c27514_1 = void 0;
+      const r13 = env30648 = {
+        $parent: env9426
+      };
+      c27514_0 = r13;
+      env30648[0] = void 0;
+      env30648[1] = void 0;
+      env30648[2] = void 0;
+      env30648[3] = void 0;
+      const id = socket.application.id;
+      env30648[0] = id;
+      if (id == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_COMMAND
+        }, "No application.");
+      }
+      const id2 = getCurrentEmbeddedActivityChannel()?.id;
+      env30648[1] = id2;
+      if (id2 == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.UNKNOWN_ERROR
+        }, "Unable to find selected channel");
+      }
+      if (await NativePermissionUtils.requestPermission(NativePermissionTypes.PHOTOS).catch(() => {
+        throw new RPCError({
+          errorCode: RPCErrors.UNKNOWN_ERROR
+        }, "Failed requesting photo permissions");
+      })) {
+        env30648[2] = (await ImagePicker.launchImageLibraryAsync({
+          mediaType: "photo",
+          includeBase64: false,
+          selectionLimit: 1
+        })).assets[0];
+        if (env30648[2] == null) {
+          throw new RPCError({
+            errorCode: RPCErrors.UNKNOWN_ERROR
+          }, "No image selected");
+        }
+        env30648[3] = await uploadImageAttachment(env30648[0], env30648[1], {
+          name: env30648[2].fileName,
+          type: env30648[2].type,
+          uri: env30648[2].uri
+        });
+        if (env30648[3] != null && env30648[3].url != null) {
+          if (!(env30648[3] instanceof APIError)) {
+            r216 = {
+              image_url: env30648[3].url
+            };
+            break L27;
+          }
+        }
+        throw new RPCError({
+          errorCode: RPCErrors.UNKNOWN_ERROR
+        }, JSON.stringify(env30648[3]));
+      }
+      throw new RPCError({
+        errorCode: RPCErrors.UNKNOWN_ERROR
+      }, "Missing photo permissions");
+    }
+    return r216;
+  }
+};
+export default r31;

modules/rpc/native/server/commands/auth.tsx

@@ -0,0 +1,45 @@
+// Metro module 13570 (f13571).
+import ApplicationStore from "../../../../applications/ApplicationStore";
+import { ApplicationFlags, ComponentActions, RPCErrors } from "../../../../../Constants";
+import RPCError from "../../../RPCError";
+import { hasApplicationFlag } from "../../../../applications/utils/ApplicationFlagUtils";
+import { ComponentDispatch } from "../../../../../utils/ComponentDispatchUtils";
+import AuthCommandsFactory from "../../../server/commands/AuthCommandsFactory";
+const r23 = AuthCommandsFactory(({ clientId, authorizations, scopes, parsedPermissions, responseType, redirectUri, codeChallenge, codeChallengeMethod, state, guildId, channelId, prompt, disableGuildSelect, disclosures, integrationType }) => new Promise((c27515_0, c27515_1) => {
+  let r12 = (integrationType != null ? authorizations == null ? void 0 : authorizations.get(integrationType) : void 0)?.application;
+  if (r12 == null) {
+    r12 = ApplicationStore.getApplication(clientId);
+  }
+  let scopes2 = scopes;
+  if (scopes == null) {
+    scopes2 = [];
+  }
+  ComponentDispatch.dispatch(ComponentActions.SHOW_OAUTH2_MODAL, {
+    clientId,
+    scopes: scopes2,
+    responseType,
+    redirectUri,
+    codeChallenge,
+    codeChallengeMethod,
+    state,
+    guildId,
+    channelId,
+    permissions: parsedPermissions,
+    prompt,
+    disableGuildSelect: typeof disableGuildSelect !== "boolean" ? disableGuildSelect === "true" : disableGuildSelect,
+    showLogout: false,
+    callback: function callback(a0) {
+      if (a0.location != null) {
+        c27515_0(a0.location);
+      } else {
+        c27515_1(new RPCError({
+          errorCode: RPCErrors.OAUTH2_ERROR
+        }, "User cancelled authorization"));
+      }
+    },
+    isEmbeddedFlow: hasApplicationFlag(r12, ApplicationFlags.EMBEDDED),
+    disclosures,
+    integrationType
+  });
+}), function onAuthorizeValidationPassed() {});
+export default r23;

modules/rpc/native/server/commands/unsupported.tsx

@@ -0,0 +1,39 @@
+// Metro module 13573 (f13574).
+import { RPCCommands } from "../../../../../Constants";
+import { unsupportedCommand, deprecatedCommand } from "../../../helpers/unavailableCommand";
+const r13 = {};
+r13[RPCCommands.SET_USER_VOICE_SETTINGS] = unsupportedCommand;
+r13[RPCCommands.SET_USER_VOICE_SETTINGS_2] = unsupportedCommand;
+r13[RPCCommands.PUSH_TO_TALK] = unsupportedCommand;
+r13[RPCCommands.SET_VOICE_SETTINGS_2] = unsupportedCommand;
+r13[RPCCommands.SET_VOICE_SETTINGS] = unsupportedCommand;
+r13[RPCCommands.SEND_ACTIVITY_JOIN_INVITE] = unsupportedCommand;
+r13[RPCCommands.CLOSE_ACTIVITY_JOIN_REQUEST] = unsupportedCommand;
+r13[RPCCommands.ACTIVITY_INVITE_USER] = unsupportedCommand;
+r13[RPCCommands.ACCEPT_ACTIVITY_INVITE] = unsupportedCommand;
+r13[RPCCommands.OPEN_SHARE_MOMENT_DIALOG] = unsupportedCommand;
+r13[RPCCommands.INVITE_BROWSER] = unsupportedCommand;
+r13[RPCCommands.DEEP_LINK] = unsupportedCommand;
+r13[RPCCommands.CONNECTIONS_CALLBACK] = unsupportedCommand;
+r13[RPCCommands.BILLING_POPUP_BRIDGE_CALLBACK] = unsupportedCommand;
+r13[RPCCommands.BRAINTREE_POPUP_BRIDGE_CALLBACK] = unsupportedCommand;
+r13[RPCCommands.GIFT_CODE_BROWSER] = unsupportedCommand;
+r13[RPCCommands.GUILD_TEMPLATE_BROWSER] = unsupportedCommand;
+r13[RPCCommands.BROWSER_HANDOFF] = unsupportedCommand;
+r13[RPCCommands.SET_OVERLAY_LOCKED] = unsupportedCommand;
+r13[RPCCommands.OPEN_OVERLAY_ACTIVITY_INVITE] = unsupportedCommand;
+r13[RPCCommands.OPEN_OVERLAY_GUILD_INVITE] = unsupportedCommand;
+r13[RPCCommands.OPEN_OVERLAY_VOICE_SETTINGS] = unsupportedCommand;
+r13[RPCCommands.VALIDATE_APPLICATION] = unsupportedCommand;
+r13[RPCCommands.GET_ENTITLEMENT_TICKET] = unsupportedCommand;
+r13[RPCCommands.START_PURCHASE] = unsupportedCommand;
+r13[RPCCommands.START_PREMIUM_PURCHASE] = unsupportedCommand;
+r13[RPCCommands.ENCOURAGE_HW_ACCELERATION] = unsupportedCommand;
+r13[RPCCommands.TOGGLE_VIDEO] = unsupportedCommand;
+r13[RPCCommands.TOGGLE_SCREENSHARE] = unsupportedCommand;
+r13[RPCCommands.SEND_GENERIC_EVENT] = deprecatedCommand;
+r13[RPCCommands.OPEN_MESSAGE] = unsupportedCommand;
+r13[RPCCommands.OPEN_INVITE] = unsupportedCommand;
+r13[RPCCommands.SHARE_INTERACTION] = unsupportedCommand;
+r13[RPCCommands.SET_SUPPRESS_NOTIFICATIONS] = unsupportedCommand;
+export default r13;

modules/rpc/native/server/commands/voiceSettings.tsx

@@ -0,0 +1,14 @@
+// Metro module 13572 (f13573).
+import { RPC_SCOPE_CONFIG } from "../../../Constants";
+import { RPCCommands } from "../../../../../Constants";
+import { OAuth2Scopes } from "../../../../../_bundle/Module8174";
+import { getDeprecatedVoiceSettings } from "../NativeRPCHelpers";
+const r19 = {};
+const GET_VOICE_SETTINGS = RPCCommands.GET_VOICE_SETTINGS;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ];
+r19[GET_VOICE_SETTINGS] = {
+  scope,
+  handler: () => getDeprecatedVoiceSettings()
+};
+export default r19;

modules/rpc/native/server/transports/WebViewPostMessageTransport.tsx

@@ -0,0 +1,10 @@
+// Metro module 10622 (f10623).
+import Logger from "../../../../debug/Logger";
+import stripSensitiveLoggingData from "../../../helpers/stripSensitiveLoggingData";
+import PostMessageTransport from "../../../transports/PostMessageTransport";
+import { validateSocketClient } from "../NativeRPCHelpers";
+import WebViewWindowProxySocketFactory from "./WebViewWindowProxySocketFactory";
+const postMessageTransport = new PostMessageTransport(validateSocketClient, new Logger("RPCServer:PostMessage"), WebViewWindowProxySocketFactory, (a0, a1, a2) => {
+  a1.info.call(a1, `Socket Message: ${a2.id}`, stripSensitiveLoggingData(a0));
+});
+export default postMessageTransport;

modules/rpc/native/server/transports/WebViewWindowProxySocketFactory.tsx

@@ -0,0 +1,18 @@
+// Metro module 10634 (f10635).
+import PostMessageProxySocket from "../../../transports/PostMessageProxySocket";
+import stripSensitiveLoggingData from "../../../helpers/stripSensitiveLoggingData";
+export default (a0) => {
+  const { origin, postMessageToRPCClient, frameId, version, encoding, logger } = a0;
+  return new PostMessageProxySocket({
+    origin,
+    postMessageToRPCClient,
+    frameId,
+    version,
+    encoding,
+    logger,
+    postClose: a0.postClose,
+    onSendingToRPCClient: (a0, a1) => {
+      logger.info(`Socket Emit: ${a1}`, stripSensitiveLoggingData(a0));
+    }
+  });
+};

modules/rpc/server/RPCServerManager.tsx

@@ -0,0 +1,495 @@
+// Metro module 13522 (f13523).
+import _slicedToArray from "../../../_bundle/_slicedToArray";
+import QuestStore from "../../quests/QuestStore";
+import ChannelStore from "../../../stores/ChannelStore";
+import GuildMemberStore from "../../../stores/GuildMemberStore";
+import GuildStore from "../../../stores/GuildStore";
+import MediaEngineStore from "../../../stores/MediaEngineStore";
+import PresenceStore from "../../../stores/PresenceStore";
+import RTCConnectionStore from "../../../stores/RTCConnectionStore";
+import RelationshipStore from "../../../stores/RelationshipStore";
+import SelectedChannelStore from "../../../stores/SelectedChannelStore";
+import UserStore from "../../../stores/UserStore";
+import VoiceStateStore from "../../../stores/VoiceStateStore";
+import { ActivityActionTypes, AnalyticEvents, RPCCloseCodes, RPCEvents, RelationshipTypes } from "../../../Constants";
+import { ActivityLayoutMode } from "../../activities/Constants";
+import { FrameLayoutModes } from "../../frames/FramesConstants";
+import { MediaEngineContextTypes } from "../../../_bundle/Module4250";
+import { isPlatformEmbedded } from "../../../utils/PlatformUtils";
+import Dispatcher from "../../../Dispatcher";
+import AnalyticsUtils from "../../../utils/AnalyticsUtils";
+import { BatchedStoreListener } from "../../../_bundle/Module589";
+import { assertNever } from "../../../utils/GlobalUtils";
+import { transformInternalTextMessage, getRemoteIconURL, transformBaseRelationship, transformApplicationRelationship } from "../RPCHelpers";
+import { getThermalState } from "../../device/useThermalState";
+import { activityInstanceConnectedParticipants } from "../helpers/activityInstanceConnectedParticipants";
+import transformUser from "../helpers/transformUser";
+import { getActivityApplicationId } from "../../quests/utils/QuestTaskUtils";
+class RPCServerManager {
+  constructor(a0) {
+    const _this = this;
+    this.handleMessage = (a0) => {
+      let r7, r41, channelId, message;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        if (a0.type === "MESSAGE_CREATE") {
+          _this.handleActivityMessage(a0);
+        }
+        const type = a0.type;
+        if (type === "MESSAGE_CREATE") {
+          if (a0.message.state === "SENDING") {
+            return void 0;
+          }
+          const MESSAGE_CREATE = RPCEvents.MESSAGE_CREATE;
+          channelId = a0.channelId;
+          message = a0.message;
+          r7 = `${MESSAGE_CREATE}${a0.message.id}`;
+          r41 = MESSAGE_CREATE;
+        } else if (type === "MESSAGE_UPDATE") {
+          r41 = RPCEvents.MESSAGE_UPDATE;
+          channelId = a0.message.channel_id;
+          message = a0.message;
+          r7 = null;
+        } else {
+          if (type !== "MESSAGE_DELETE") {
+            return assertNever(a0);
+          }
+          const MESSAGE_DELETE = RPCEvents.MESSAGE_DELETE;
+          channelId = a0.channelId;
+          message = {
+            id: a0.id
+          };
+          r7 = `${MESSAGE_DELETE}${a0.id}`;
+          r41 = MESSAGE_DELETE;
+        }
+        if (channelId != null) {
+          _this.rpcServer.dispatchToSubscriptions(r41, {
+            channel_id: channelId
+          }, {
+            channel_id: channelId,
+            message: transformInternalTextMessage(message)
+          }, r7);
+        }
+      }
+    };
+    this.handleSpeaking = (a0) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const r6 = a0.speakingFlags !== 0 ? RPCEvents.SPEAKING_START : RPCEvents.SPEAKING_STOP;
+        if (a0.context === MediaEngineContextTypes.DEFAULT) {
+          const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
+          if (voiceChannelId != null) {
+            const channel = ChannelStore.getChannel(voiceChannelId);
+            if (channel == null) {
+              return void 0;
+            }
+            const voiceState = VoiceStateStore.getVoiceState(channel.getGuildId(), a0.userId);
+            if (voiceState == null) {
+              return void 0;
+            }
+            _this.rpcServer.dispatchToSubscriptions(r6, {
+              channel_id: voiceState.channelId
+            }, {
+              channel_id: voiceState.channelId,
+              user_id: a0.userId
+            });
+          }
+        }
+      }
+    };
+    this.handleVoiceChannelSelect = ({ guildId, channelId }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.VOICE_CHANNEL_SELECT, {}, {
+          channel_id: channelId,
+          guild_id: guildId
+        });
+      }
+    };
+    this.handleNotificationCreate = ({ channelId, message, icon, title, body }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const rpcServer = _this.rpcServer;
+        const NOTIFICATION_CREATE = RPCEvents.NOTIFICATION_CREATE;
+        const r21 = {
+          channel_id: channelId,
+          message: transformInternalTextMessage(message),
+          icon_url: null,
+          title: null,
+          body: null
+        };
+        const icon_url = icon != null ? getRemoteIconURL(icon) : null;
+        const r30 = {};
+        r21.icon_url = icon_url;
+        r21.title = title;
+        r21.body = body;
+        rpcServer.dispatchToSubscriptions(NOTIFICATION_CREATE, r30, r21);
+      }
+    };
+    this.handleActivityJoin = ({ applicationId, parentApplicationId, secret, intent, embedded }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const r15 = {
+          application_id: applicationId,
+          secret
+        };
+        if (embedded) {
+          r15.intent = intent;
+        }
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_JOIN, (a0) => a0.socket.application.id === applicationId || parentApplicationId != null && a0.socket.application.parentId === parentApplicationId, r15);
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.GAME_JOIN, (a0) => a0.socket.application.id === applicationId, r15);
+      }
+    };
+    this.handleActivityLayoutModeUpdate = ({ applicationId: applicationId2, layoutMode }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_PIP_MODE_UPDATE, (a0) => a0.socket.application.id === applicationId2, {
+          is_pip_mode: layoutMode !== ActivityLayoutMode.FOCUSED
+        });
+        const r21 = {
+          layout_mode: layoutMode
+        };
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_LAYOUT_MODE_UPDATE, (a0) => a0.socket.application.id === applicationId2, r21);
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.FRAME_LAYOUT_MODE_UPDATE, (a0) => a0.socket.application.id === applicationId2, r21);
+      }
+    };
+    this.handleFrameUpdateLayoutMode = ({ applicationId: applicationId3, layoutMode }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const layout_mode = layoutMode === FrameLayoutModes.PIP ? ActivityLayoutMode.PIP : ActivityLayoutMode.FOCUSED;
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_PIP_MODE_UPDATE, (a0) => a0.socket.application.id === applicationId3, {
+          is_pip_mode: layout_mode !== ActivityLayoutMode.FOCUSED
+        });
+        const r26 = {
+          layout_mode
+        };
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_LAYOUT_MODE_UPDATE, (a0) => a0.socket.application.id === applicationId3, r26);
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.FRAME_LAYOUT_MODE_UPDATE, (a0) => a0.socket.application.id === applicationId3, r26);
+      }
+    };
+    this.handleThermalStateChange = ({ applicationId: applicationId4 }) => {
+      if (_this.rpcServer.subscriptions.length !== 0 && applicationId4 != null) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.THERMAL_STATE_UPDATE, (a0) => a0.socket.application.id === applicationId4, {
+          thermal_state: getThermalState()
+        });
+      }
+    };
+    this.handleScreenOrientationUpdate = ({ screenOrientation }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ORIENTATION_UPDATE, {}, {
+          screen_orientation: screenOrientation
+        });
+      }
+    };
+    this.handleEmbeddedActivityUpdate = () => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_INSTANCE_PARTICIPANTS_UPDATE, {}, activityInstanceConnectedParticipants());
+      }
+    };
+    this.handleActivityMessage = ({ channelId, message }) => {
+      let application_id;
+      application_id = void 0;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const { application, activity } = message;
+        if (application != null && activity != null && activity.party_id != null) {
+          const user = UserStore.getUser(message.author?.id);
+          if (user != null) {
+            const currentUser = UserStore.getCurrentUser();
+            if (currentUser != null && user.id !== currentUser.id) {
+              const activity2 = activity.type === ActivityActionTypes.JOIN_REQUEST ? PresenceStore.getApplicationActivity(currentUser.id, application.id) : PresenceStore.getApplicationActivity(user.id, application.id);
+              if (activity2 != null && activity2.party != null && activity2.party.id === activity.party_id) {
+                application_id = activity2.application_id;
+                const type = activity.type;
+                if (ActivityActionTypes.JOIN === type) {
+                  _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_INVITE, (a0) => a0.socket.application.id === application_id, {
+                    user: transformUser(user),
+                    activity: activity2,
+                    type: activity.type,
+                    channel_id: channelId,
+                    message_id: message.id
+                  });
+                } else if (ActivityActionTypes.JOIN_REQUEST === type) {
+                  _this.rpcServer.dispatchToSubscriptions(RPCEvents.ACTIVITY_JOIN_REQUEST, (a0) => a0.socket.application.id === application_id, {
+                    user: transformUser(user),
+                    activity: activity2,
+                    type: activity.type,
+                    channel_id: channelId,
+                    message_id: message.id
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    this.handleOAuth2TokenRevoke = ({ accessToken }) => {
+      _this.rpcServer.sockets.forEach((socket) => {
+        if (socket.authorization.accessToken === accessToken) {
+          socket.close(RPCCloseCodes.TOKEN_REVOKED, "Token revoked");
+        }
+      });
+    };
+    this.handleGuildCreate = (a0) => {
+      const id = a0.guild.id;
+      const guild = GuildStore.getGuild(id);
+      if (_this.rpcServer.subscriptions.length !== 0 && guild != null) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.GUILD_CREATE, {}, {
+          id,
+          name: guild.name
+        });
+      }
+    };
+    this.handleChannelCreate = ({ channel }) => {
+      const { id, name, type } = channel;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.CHANNEL_CREATE, {}, {
+          id,
+          name,
+          type
+        });
+      }
+    };
+    this.handleLogout = () => {
+      _this.rpcServer.sockets.forEach((socket) => socket.close(RPCCloseCodes.CLOSE_NORMAL, "User logout"));
+    };
+    this.handleRelationshipAdd = ({ relationship }) => {
+      let c27486_0;
+      const { id, type } = relationship;
+      c27486_0 = void 0;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const user = UserStore.getUser(id);
+        if (user != null) {
+          c27486_0 = transformBaseRelationship(type, user);
+          _this.rpcServer.dispatchToSubscriptions(RPCEvents.RELATIONSHIP_UPDATE, {}, (a0) => transformApplicationRelationship(c27486_0, a0.socket.application.id));
+        }
+      }
+    };
+    this.handleRelationshipUpdate = ({ relationship }) => {
+      let c27487_0;
+      const { id, type } = relationship;
+      c27487_0 = void 0;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const user = UserStore.getUser(id);
+        if (user != null) {
+          c27487_0 = transformBaseRelationship(type, user);
+          _this.rpcServer.dispatchToSubscriptions(RPCEvents.RELATIONSHIP_UPDATE, {}, (a0) => transformApplicationRelationship(c27487_0, a0.socket.application.id));
+        }
+      }
+    };
+    this.handleRelationshipRemove = (a0) => {
+      let c27488_0;
+      const id = a0.relationship.id;
+      c27488_0 = void 0;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const user = UserStore.getUser(id);
+        if (user != null) {
+          c27488_0 = transformBaseRelationship(RelationshipTypes.NONE, user);
+          _this.rpcServer.dispatchToSubscriptions(RPCEvents.RELATIONSHIP_UPDATE, {}, (a0) => transformApplicationRelationship(c27488_0, a0.socket.application.id));
+        }
+      }
+    };
+    this.handlePresenceUpdates = ({ updates }) => {
+      let c27489_1;
+      c27489_1 = void 0;
+      let c27489_0 = _this;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const set = new Set(updates.map((update) => update.user.id));
+        const _loop = function _loop() {
+          const relationshipType = RelationshipStore.getRelationshipType(c27489_1);
+          if (relationshipType === RelationshipTypes.NONE) {
+            return 0;
+          }
+          const user = UserStore.getUser(c27489_1);
+          if (user == null) {
+            return 0;
+          }
+          let c30633_0 = transformBaseRelationship(relationshipType, user);
+          c27489_0.rpcServer.dispatchToSubscriptions(RPCEvents.RELATIONSHIP_UPDATE, {}, (a0) => transformApplicationRelationship(c30633_0, a0.socket.application.id));
+        };
+        for (const item of set.values()) {
+          c27489_1 = item;
+          _loop();
+        }
+      }
+    };
+    this.handlePresencesReplace = () => {
+      let c27490_1, c27490_2;
+      let c27490_0 = _this;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const _loop2 = function _loop2() {
+          if (c27490_2 === RelationshipTypes.NONE) {
+            return 0;
+          }
+          const user = UserStore.getUser(c27490_1);
+          if (user == null) {
+            return 0;
+          }
+          let c30634_0 = transformBaseRelationship(c27490_2, user);
+          c27490_0.rpcServer.dispatchToSubscriptions(RPCEvents.RELATIONSHIP_UPDATE, {}, (a0) => transformApplicationRelationship(c30634_0, a0.socket.application.id));
+        };
+        for (const item of RelationshipStore.getMutableRelationships().entries()) {
+          [c27490_1, c27490_2] = item;
+          _loop2();
+        }
+      }
+    };
+    this.handleUserUpdate = (a0) => {
+      let c27491_0;
+      const id = a0.user.id;
+      c27491_0 = void 0;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        const relationshipType = RelationshipStore.getRelationshipType(id);
+        if (relationshipType !== RelationshipTypes.NONE) {
+          const user = UserStore.getUser(id);
+          if (user != null) {
+            c27491_0 = transformBaseRelationship(relationshipType, user);
+            _this.rpcServer.dispatchToSubscriptions(RPCEvents.RELATIONSHIP_UPDATE, {}, (a0) => transformApplicationRelationship(c27491_0, a0.socket.application.id));
+          }
+        }
+      }
+    };
+    this.handleEntitlementCreate = ({ entitlement }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ENTITLEMENT_CREATE, (a0) => a0.socket.application.id === entitlement.application_id, {
+          entitlement
+        });
+      }
+    };
+    this.handleEntitlementDelete = ({ entitlement: entitlement2 }) => {
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        _this.rpcServer.dispatchToSubscriptions(RPCEvents.ENTITLEMENT_DELETE, (a0) => a0.socket.application.id === entitlement2.application_id, {
+          entitlement: entitlement2
+        });
+      }
+    };
+    this.handleQuestEnrollSuccess = ({ enrolledQuestUserStatus }) => {
+      let questId, activityApplicationId;
+      questId = void 0;
+      activityApplicationId = void 0;
+      if (_this.rpcServer.subscriptions.length !== 0) {
+        questId = enrolledQuestUserStatus.questId;
+        const quest = QuestStore.getQuest(questId);
+        if (quest != null) {
+          activityApplicationId = getActivityApplicationId(quest);
+          if (activityApplicationId != null) {
+            _this.rpcServer.dispatchToSubscriptions(RPCEvents.QUEST_ENROLLMENT_STATUS_UPDATE, (a0) => a0.socket.application.id === activityApplicationId && a0.args?.quest_id === questId, {
+              quest_id: questId,
+              is_enrolled: enrolledQuestUserStatus.enrolledAt != null,
+              enrolled_at: enrolledQuestUserStatus.enrolledAt
+            });
+          }
+        }
+      }
+    };
+    this.rpcServer = a0.server;
+    this.transports = a0.transports;
+    this.rpcCommandHandlers = a0.commands;
+    this.rpcEventHandlers = a0.events;
+    this.stores = a0.stores;
+    this.registerTransportsForEmbeddedPlatform = a0.registerTransportsForEmbeddedPlatform;
+  }
+  loadServer() {
+    let r22;
+    if (isPlatformEmbedded) {
+      this.registerTransportsForEmbeddedPlatform();
+    }
+    let r31 = this.transports[Symbol.iterator]();
+    const next = r31.next;
+    while (true) {
+      const r7 = r31 === void 0 ? void 0 : (r22 = next.call(r31)).done ? r31 = void 0 : r22.value;
+      if (r31 === void 0) {
+        for (const item of Object.entries(this.rpcCommandHandlers)) {
+          const r50 = _slicedToArray(item, 2);
+          this.rpcServer.setCommandHandler(r50[0], r50[1]);
+        }
+        const rpcEventHandlers = this.rpcEventHandlers;
+        for (const item2 of Object.entries(rpcEventHandlers)) {
+          const r66 = _slicedToArray(item2, 2);
+          this.rpcServer.setEventHandler(r66[0], r66[1]);
+        }
+        return void 0;
+      } else {
+        try {
+          this.rpcServer.registerTransport(r7);
+        } catch (r37) {
+          if (r31 !== void 0 && typeof r31.return === "function") {
+            try {
+              r31.return();
+            } catch {}
+          }
+          throw r37;
+        }
+      }
+    }
+  }
+  init() {
+    this.rpcServer.getCurrentUser = () => UserStore.getCurrentUser();
+    this.rpcServer.onConnect = (a0) => {
+      Dispatcher.dispatch({
+        type: "RPC_APP_CONNECTED",
+        socketId: a0.id,
+        application: a0.application
+      });
+      AnalyticsUtils.track(AnalyticEvents.AUTHORIZED_APP_CONNECTED, {
+        app_id: a0.application.id,
+        transport: a0.transport
+      });
+    };
+    this.rpcServer.onDisconnect = (a0, a1) => {
+      Dispatcher.dispatch({
+        type: "RPC_APP_DISCONNECTED",
+        socketId: a0.id,
+        application: a0.application,
+        reason: a1
+      });
+    };
+    new BatchedStoreListener([ChannelStore, GuildMemberStore, PresenceStore, VoiceStateStore, MediaEngineStore, RTCConnectionStore].concat(this.stores), () => this.rpcServer.updateSubscriptions()).attach("RPCServerManager");
+    Dispatcher.subscribe("MESSAGE_CREATE", this.handleMessage);
+    Dispatcher.subscribe("MESSAGE_UPDATE", this.handleMessage);
+    Dispatcher.subscribe("MESSAGE_DELETE", this.handleMessage);
+    Dispatcher.subscribe("SPEAKING", this.handleSpeaking);
+    Dispatcher.subscribe("OAUTH2_TOKEN_REVOKE", this.handleOAuth2TokenRevoke);
+    Dispatcher.subscribe("GUILD_CREATE", this.handleGuildCreate);
+    Dispatcher.subscribe("CHANNEL_CREATE", this.handleChannelCreate);
+    Dispatcher.subscribe("LOGOUT", this.handleLogout);
+    Dispatcher.subscribe("VOICE_CHANNEL_SELECT", this.handleVoiceChannelSelect);
+    Dispatcher.subscribe("RPC_NOTIFICATION_CREATE", this.handleNotificationCreate);
+    Dispatcher.subscribe("ACTIVITY_JOIN", this.handleActivityJoin);
+    Dispatcher.subscribe("ACTIVITY_LAYOUT_MODE_UPDATE", this.handleActivityLayoutModeUpdate);
+    Dispatcher.subscribe("FRAME_UPDATE_LAYOUT_MODE", this.handleFrameUpdateLayoutMode);
+    Dispatcher.subscribe("THERMAL_STATE_CHANGE", this.handleThermalStateChange);
+    Dispatcher.subscribe("ACTIVITY_SCREEN_ORIENTATION_UPDATE", this.handleScreenOrientationUpdate);
+    Dispatcher.subscribe("EMBEDDED_ACTIVITY_UPDATE", this.handleEmbeddedActivityUpdate);
+    Dispatcher.subscribe("RELATIONSHIP_ADD", this.handleRelationshipAdd);
+    Dispatcher.subscribe("RELATIONSHIP_UPDATE", this.handleRelationshipUpdate);
+    Dispatcher.subscribe("RELATIONSHIP_REMOVE", this.handleRelationshipRemove);
+    Dispatcher.subscribe("PRESENCE_UPDATES", this.handlePresenceUpdates);
+    Dispatcher.subscribe("PRESENCES_REPLACE", this.handlePresencesReplace);
+    Dispatcher.subscribe("USER_UPDATE", this.handleUserUpdate);
+    Dispatcher.subscribe("ENTITLEMENT_CREATE", this.handleEntitlementCreate);
+    Dispatcher.subscribe("ENTITLEMENT_DELETE", this.handleEntitlementDelete);
+    Dispatcher.subscribe("QUESTS_ENROLL_SUCCESS", this.handleQuestEnrollSuccess);
+  }
+  terminate() {
+    Dispatcher.unsubscribe("MESSAGE_CREATE", this.handleMessage);
+    Dispatcher.unsubscribe("MESSAGE_UPDATE", this.handleMessage);
+    Dispatcher.unsubscribe("MESSAGE_DELETE", this.handleMessage);
+    Dispatcher.unsubscribe("SPEAKING", this.handleSpeaking);
+    Dispatcher.unsubscribe("OAUTH2_TOKEN_REVOKE", this.handleOAuth2TokenRevoke);
+    Dispatcher.unsubscribe("GUILD_CREATE", this.handleGuildCreate);
+    Dispatcher.unsubscribe("CHANNEL_CREATE", this.handleChannelCreate);
+    Dispatcher.unsubscribe("LOGOUT", this.handleLogout);
+    Dispatcher.unsubscribe("VOICE_CHANNEL_SELECT", this.handleVoiceChannelSelect);
+    Dispatcher.unsubscribe("RPC_NOTIFICATION_CREATE", this.handleNotificationCreate);
+    Dispatcher.unsubscribe("ACTIVITY_JOIN", this.handleActivityJoin);
+    Dispatcher.unsubscribe("ACTIVITY_LAYOUT_MODE_UPDATE", this.handleActivityLayoutModeUpdate);
+    Dispatcher.unsubscribe("FRAME_UPDATE_LAYOUT_MODE", this.handleFrameUpdateLayoutMode);
+    Dispatcher.unsubscribe("THERMAL_STATE_CHANGE", this.handleThermalStateChange);
+    Dispatcher.unsubscribe("ACTIVITY_SCREEN_ORIENTATION_UPDATE", this.handleScreenOrientationUpdate);
+    Dispatcher.unsubscribe("EMBEDDED_ACTIVITY_UPDATE", this.handleEmbeddedActivityUpdate);
+    Dispatcher.unsubscribe("RELATIONSHIP_ADD", this.handleRelationshipAdd);
+    Dispatcher.unsubscribe("RELATIONSHIP_UPDATE", this.handleRelationshipUpdate);
+    Dispatcher.unsubscribe("RELATIONSHIP_REMOVE", this.handleRelationshipRemove);
+    Dispatcher.unsubscribe("PRESENCE_UPDATES", this.handlePresenceUpdates);
+    Dispatcher.unsubscribe("PRESENCES_REPLACE", this.handlePresencesReplace);
+    Dispatcher.unsubscribe("USER_UPDATE", this.handleUserUpdate);
+    Dispatcher.unsubscribe("ENTITLEMENT_CREATE", this.handleEntitlementCreate);
+    Dispatcher.unsubscribe("ENTITLEMENT_DELETE", this.handleEntitlementDelete);
+    Dispatcher.unsubscribe("QUESTS_ENROLL_SUCCESS", this.handleQuestEnrollSuccess);
+  }
+}
+export default RPCServerManager;

modules/rpc/server/commands/AuthCommandsFactory.tsx

@@ -0,0 +1,655 @@
+// Metro module 13571 (f13572).
+import _slicedToArray from "../../../../_bundle/_slicedToArray";
+import ApplicationStore from "../../../applications/ApplicationStore";
+import ApplicationRecord from "../../../../records/ApplicationRecord";
+import UserStore from "../../../../stores/UserStore";
+import { RPC_AUTHENTICATED_SCOPE, TransportTypes, RPC_PRIVATE_SCOPE } from "../../Constants";
+import { ApplicationFlags, RPCErrors, Endpoints, RPCCommands } from "../../../../Constants";
+import LeakyBucket from "../../../../_bundle/LeakyBucket";
+import Durations from "../../../../utils/Durations";
+import { Storage } from "../../../../_bundle/Module595";
+import RPCError from "../../RPCError";
+import { hasApplicationFlag } from "../../../applications/utils/ApplicationFlagUtils";
+import { ApplicationIntegrationType } from "../../../../_bundle/Module8028";
+import { fetchApplication } from "../../../premium_apps/ApplicationSubscriptionsHttpApi";
+import * as _actions from "../../../oauth2/actions";
+import { fetchAuthorization } from "../../../oauth2/actions";
+import { getDisclosures } from "../../../applications/disclosures";
+import { OAuth2Prompts } from "../../../oauth2/types";
+import { NONE } from "../../../../utils/PermissionUtils";
+import { deserialize } from "../../../../_bundle/HighLow";
+import { HTTP } from "../../../../_bundle/sendRequest";
+import Dispatcher from "../../../../Dispatcher";
+import { createRPCCommand } from "../../../../_bundle/Module13535";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import Module1464 from "../../../../_bundle/Module1464";
+function $mk116550($env) {
+  return function isUserInstallable(a0) {
+    let r12 = hasApplicationFlag(a0, ApplicationFlags.EMBEDDED);
+    if (r12) {
+      const r2 = a0 == null;
+      let r13 = void 0;
+      if (!r2) {
+        const integrationTypesConfig = a0.integrationTypesConfig;
+        r13 = integrationTypesConfig == null ? void 0 : integrationTypesConfig[ApplicationIntegrationType.USER_INSTALL];
+      }
+      r12 = r13 != null;
+    }
+    return r12;
+  };
+}
+function $mk116551($env) {
+  return (a0) => {
+    if (a0 == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.UNKNOWN_ERROR
+      }, "Unknown error occurred");
+    }
+    const r18 = a0.split(/#|\?/);
+    const r26 = Module1464.parse(r18[r18.length - 1]);
+    if (r26.error != null) {
+      const r58 = {
+        errorCode: RPCErrors.OAUTH2_ERROR
+      };
+      const error = r26.error;
+      let error_description = r26.error_description;
+      if (error_description == null) {
+        error_description = "unknown error";
+      }
+      throw new RPCError(r58, `OAuth2 Error: ${error}: ${error_description}`);
+    }
+    const r28 = $env;
+    const r10 = r28[2];
+    const { access_token, scope, expires_in } = r26;
+    let r34 = Storage.get(c9428_16);
+    if (r34 == null) {
+      r34 = {};
+    }
+    r34[r10] = {
+      accessToken: access_token,
+      scope,
+      expires: Date.now() + expires_in
+    };
+    Storage.set(c9428_16, r34);
+    return (0, authenticate)(r28[0], r26.access_token);
+  };
+}
+let authenticate, c9428_16, c9428_17;
+let env9428 = {};
+const authorizeWithPrompt = async function authorizeWithPrompt(c27516_0, c27516_1, c27516_2) {
+  let r300, r502, location2;
+  let c27516_3, createFromServer, c27516_5, c27516_6, c27516_7, c27516_8, c27516_10;
+  let c27516_9 = 0;
+  const r23 = env9428;
+  L57: {
+    L45: {
+      try {
+        let env30649;
+        c27516_8 = r23;
+        const r58 = env30649 = {
+          $parent: r23
+        };
+        c27516_7 = r58;
+        env30649[0] = void 0;
+        env30649[1] = void 0;
+        env30649[2] = void 0;
+        env30649[3] = void 0;
+        env30649[4] = void 0;
+        env30649[5] = void 0;
+        env30649[6] = void 0;
+        env30649[7] = void 0;
+        env30649[8] = void 0;
+        env30649[9] = void 0;
+        env30649[10] = void 0;
+        env30649[11] = void 0;
+        env30649[12] = void 0;
+        env30649[13] = void 0;
+        env30649[14] = void 0;
+        env30649[15] = void 0;
+        env30649[16] = void 0;
+        env30649[17] = void 0;
+        env30649[18] = void 0;
+        env30649[0] = c27516_0.client_id;
+        let response_type = c27516_0.response_type;
+        if (response_type === void 0) {
+          response_type = "code";
+        }
+        env30649[1] = response_type;
+        env30649[2] = c27516_0.redirect_uri;
+        env30649[3] = c27516_0.code_challenge;
+        env30649[4] = c27516_0.code_challenge_method;
+        env30649[5] = c27516_0.state;
+        env30649[6] = c27516_0.nonce;
+        env30649[7] = c27516_0.scope;
+        env30649[8] = c27516_0.permissions;
+        env30649[9] = c27516_0.guild_id;
+        env30649[10] = c27516_0.channel_id;
+        env30649[11] = c27516_0.prompt;
+        env30649[12] = c27516_0.disable_guild_select;
+        env30649[13] = c27516_0.integration_type;
+        env30649[14] = c27516_0.pid;
+        env30649[15] = c27516_0.signal;
+        env30649[16] = c27516_0.isSocketRpcPrivateScope;
+        env30649[17] = c27516_1;
+        env30649[18] = c27516_2;
+        env30649[19] = void 0;
+        env30649[20] = void 0;
+        env30649[21] = void 0;
+        env30649[22] = void 0;
+        env30649[23] = void 0;
+        env30649[24] = void 0;
+        env30649[25] = void 0;
+        env30649[26] = void 0;
+        env30649[27] = void 0;
+        env30649[28] = void 0;
+        env30649[29] = void 0;
+        env30649[30] = void 0;
+        env30649[31] = void 0;
+        await void 0;
+        const r100 = "Redirect URI cannot be used in the RPC OAuth2 Authorization flow";
+        if (env30649[15]?.aborted) {
+          throw new RPCError({
+            errorCode: RPCErrors.UNKNOWN_ERROR
+          }, "Request aborted");
+        }
+        if (env30649[0] == null) {
+          throw new RPCError({
+            errorCode: RPCErrors.OAUTH2_ERROR
+          }, "No Client ID provided");
+        }
+        if (!env30649[16] && env30649[2] != null) {
+          throw new RPCError({
+            errorCode: RPCErrors.OAUTH2_ERROR
+          }, r100);
+        }
+        env30649[23] = [];
+        if (typeof env30649[7] === "string") {
+          env30649[23] = env30649[7].split(" ").filter((item) => item.length > 0);
+        } else if (Array.isArray(env30649[7])) {
+          env30649[23] = env30649[7];
+        }
+        if (UserStore.getCurrentUser() == null) {
+          throw new RPCError({
+            errorCode: RPCErrors.OAUTH2_ERROR
+          }, "Client is not logged in");
+        }
+        L36: {
+          if (env30649[13] != null) {
+            env30649[19] = Number(env30649[13]);
+          } else {
+            env30649[32] = $mk116550(env9428);
+            env30649[24] = ApplicationStore.getApplication(env30649[0]);
+            if (!(0, env30649[32])(env30649[24])) {
+              c27516_6 = env30649[32];
+              c27516_5 = ApplicationRecord;
+              createFromServer = ApplicationRecord.createFromServer;
+              const application = await fetchApplication(env30649[0], env30649[15]);
+              const r256 = c27516_5;
+              const r257 = c27516_6;
+              const r259 = createFromServer.call(r256, application);
+              env30649[24] = r259;
+              env30649[19] = r257(r259) ? ApplicationIntegrationType.USER_INSTALL : ApplicationIntegrationType.GUILD_INSTALL;
+              c27516_9 = 1;
+              r300 = Promise.all([fetchAuthorization({
+                clientId: env30649[0],
+                scopes: env30649[23],
+                responseType: env30649[1],
+                redirectUri: env30649[2],
+                codeChallenge: env30649[3],
+                codeChallengeMethod: env30649[4],
+                state: env30649[5],
+                integrationType: env30649[19],
+                signal: env30649[15]
+              }), getDisclosures(env30649[0])]);
+              break L36;
+            }
+            env30649[19] = ApplicationIntegrationType.USER_INSTALL;
+          }
+          c27516_9 = 1;
+          r300 = Promise.all([fetchAuthorization({
+            clientId: env30649[0],
+            scopes: env30649[23],
+            responseType: env30649[1],
+            redirectUri: env30649[2],
+            codeChallenge: env30649[3],
+            codeChallengeMethod: env30649[4],
+            state: env30649[5],
+            integrationType: env30649[19],
+            signal: env30649[15]
+          }), getDisclosures(env30649[0])]);
+        }
+        env30649[25] = await r300;
+        env30649[26] = (0, _slicedToArray)(env30649[25], 2);
+        env30649[20] = env30649[26][0];
+        env30649[27] = env30649[26][1];
+        env30649[21] = env30649[27].disclosures;
+        env30649[22] = env30649[27].allAcked;
+        c27516_9 = 0;
+        if (env30649[11] === OAuth2Prompts.NONE && env30649[20] != null && env30649[20].authorized) {
+          if (env30649[22]) {
+            c27516_9 = 2;
+            location2 = (await _actions.authorize({
+              authorize: true,
+              clientId: env30649[0],
+              scopes: env30649[23],
+              responseType: env30649[1],
+              redirectUri: env30649[2],
+              codeChallenge: env30649[3],
+              codeChallengeMethod: env30649[4],
+              state: env30649[5],
+              nonce: env30649[6],
+              integrationType: env30649[19]
+            })).location;
+            c27516_9 = 0;
+            break L45;
+          }
+        }
+        const r355 = env30649[18];
+        if (r355 != null) {
+          r355(env30649[20].application, env30649[10], env30649[14]);
+        }
+        env30649[30] = NONE;
+        c27516_9 = 3;
+        const r427 = env30649[8];
+        c27516_3 = r427;
+        if (r427 == null) {
+          c27516_3 = 0;
+        }
+        env30649[30] = deserialize(c27516_3);
+        c27516_9 = 0;
+        env30649[31] = void 0;
+        if (env30649[20].integration_type != null && Object.values(ApplicationIntegrationType).includes(env30649[20].integration_type)) {
+          const map = new Map();
+          env30649[31] = map;
+          map.set(env30649[20].integration_type, env30649[20]);
+        }
+        if (c9428_17[env30649[20].application.id] != null) {
+          await c9428_17[env30649[20].application.id].process();
+          if (!env30649[15]?.aborted) {
+            r502 = (0, env30649[17])({
+              clientId: env30649[0],
+              authorizations: env30649[31],
+              scopes: env30649[23],
+              parsedPermissions: env30649[30],
+              responseType: env30649[1],
+              redirectUri: env30649[2],
+              codeChallenge: env30649[3],
+              codeChallengeMethod: env30649[4],
+              state: env30649[5],
+              guildId: env30649[9],
+              channelId: env30649[10],
+              prompt: env30649[11],
+              disableGuildSelect: env30649[12],
+              disclosures: env30649[21],
+              integrationType: env30649[19],
+              pid: env30649[14],
+              signal: env30649[15]
+            });
+            break L57;
+          }
+          throw new RPCError({
+            errorCode: RPCErrors.UNKNOWN_ERROR
+          }, "Request aborted");
+        }
+        r502 = (0, env30649[17])({
+          clientId: env30649[0],
+          authorizations: env30649[31],
+          scopes: env30649[23],
+          parsedPermissions: env30649[30],
+          responseType: env30649[1],
+          redirectUri: env30649[2],
+          codeChallenge: env30649[3],
+          codeChallengeMethod: env30649[4],
+          state: env30649[5],
+          guildId: env30649[9],
+          channelId: env30649[10],
+          prompt: env30649[11],
+          disableGuildSelect: env30649[12],
+          disclosures: env30649[21],
+          integrationType: env30649[19],
+          pid: env30649[14],
+          signal: env30649[15]
+        });
+        break L57;
+      } catch ($e) {
+        const r56 = $e;
+        let r8 = r56;
+        c27516_10 = r56;
+        let r57 = c27516_9;
+        if (r57 !== 0) {
+          while (true) {
+            if (r57 === 1) {
+              try {
+                const r774 = c27516_10;
+                c27516_9 = 0;
+                env30649[28] = r774.body;
+                throw new RPCError({
+                  errorCode: RPCErrors.OAUTH2_ERROR
+                }, `OAuth2 Authorization Error: ${env30649[28]?.message || "Unknown Error"}`);
+              } catch (r771) {
+                r8 = r771;
+                c27516_10 = r771;
+                r57 = c27516_9;
+                if (r57 === 0) {
+                  break;
+                }
+              }
+            } else if (r57 === 2) {
+              try {
+                const r748 = c27516_10;
+                c27516_9 = 0;
+                env30649[29] = r748.body;
+                throw new RPCError({
+                  errorCode: RPCErrors.OAUTH2_ERROR
+                }, `OAuth2 Authorize Error: ${env30649[29]?.message || "Unknown Error"}`);
+              } catch (r745) {
+                r8 = r745;
+                c27516_10 = r745;
+                r57 = c27516_9;
+                if (r57 === 0) {
+                  break;
+                }
+              }
+            } else {
+              try {
+                c27516_9 = 0;
+                env30649[31] = void 0;
+                if (env30649[20].integration_type != null && Object.values(ApplicationIntegrationType).includes(env30649[20].integration_type)) {
+                  const map2 = new Map();
+                  env30649[31] = map2;
+                  map2.set(env30649[20].integration_type, env30649[20]);
+                }
+                if (c9428_17[env30649[20].application.id] != null) {
+                  await c9428_17[env30649[20].application.id].process();
+                  if (!env30649[15]?.aborted) {
+                    r502 = (0, env30649[17])({
+                      clientId: env30649[0],
+                      authorizations: env30649[31],
+                      scopes: env30649[23],
+                      parsedPermissions: env30649[30],
+                      responseType: env30649[1],
+                      redirectUri: env30649[2],
+                      codeChallenge: env30649[3],
+                      codeChallengeMethod: env30649[4],
+                      state: env30649[5],
+                      guildId: env30649[9],
+                      channelId: env30649[10],
+                      prompt: env30649[11],
+                      disableGuildSelect: env30649[12],
+                      disclosures: env30649[21],
+                      integrationType: env30649[19],
+                      pid: env30649[14],
+                      signal: env30649[15]
+                    });
+                    break L57;
+                  }
+                  throw new RPCError({
+                    errorCode: RPCErrors.UNKNOWN_ERROR
+                  }, "Request aborted");
+                }
+                r502 = (0, env30649[17])({
+                  clientId: env30649[0],
+                  authorizations: env30649[31],
+                  scopes: env30649[23],
+                  parsedPermissions: env30649[30],
+                  responseType: env30649[1],
+                  redirectUri: env30649[2],
+                  codeChallenge: env30649[3],
+                  codeChallengeMethod: env30649[4],
+                  state: env30649[5],
+                  guildId: env30649[9],
+                  channelId: env30649[10],
+                  prompt: env30649[11],
+                  disableGuildSelect: env30649[12],
+                  disclosures: env30649[21],
+                  integrationType: env30649[19],
+                  pid: env30649[14],
+                  signal: env30649[15]
+                });
+                break L57;
+              } catch (r606) {
+                r8 = r606;
+                c27516_10 = r606;
+                r57 = c27516_9;
+                if (r57 === 0) {
+                  break;
+                }
+              }
+            }
+          }
+        }
+        throw r8;
+      }
+    }
+    return location2;
+  }
+  return r502;
+};
+authenticate = function authenticate(a0, a1) {
+  const accessToken = a1;
+  if (a0.authorization.accessToken) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, "Already authenticated");
+  }
+  if (a0.authorization.authing) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, "Already authenticating");
+  }
+  a0.authorization.authing = true;
+  return HTTP.get({
+    url: Endpoints.OAUTH2_CURRENT_AUTH,
+    headers: {
+      Authorization: `Bearer ${a1}`
+    },
+    oldFormErrors: true,
+    rejectWithError: false
+  }).then((result) => {
+    a0.authorization.authing = false;
+    const body = result.body;
+    const { application, user, scopes, expires } = body;
+    if (a0.application.id !== application.id) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CLIENTID
+      }, "Application does not match the connection's");
+    }
+    const currentUser = UserStore.getCurrentUser();
+    if (currentUser != null && user && currentUser.id === user.id) {
+      a0.authorization.scopes = [...a0.authorization.scopes, ...scopes, RPC_AUTHENTICATED_SCOPE];
+      a0.authorization.accessToken = accessToken;
+      a0.authorization.expires = new Date(expires);
+      Dispatcher.dispatch({
+        type: "RPC_APP_AUTHENTICATED",
+        socketId: a0.id,
+        application: a0.application
+      });
+      return {
+        ...result.body,
+        access_token: accessToken
+      };
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_TOKEN
+    }, "Token does not match current user");
+  }, () => {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_TOKEN
+    }, `Invalid access token: ${accessToken}`);
+  }).catch((error) => {
+    a0.authorization.authing = false;
+    throw error;
+  });
+};
+c9428_16 = "CachedTokens";
+c9428_17 = {
+  "1273616940451102832": new LeakyBucket(2, 1 * Durations.Millis.MINUTE)
+};
+export default function createAuthCommandHandlers(a0, a1) {
+  let env20539 = {
+    $parent: env9428
+  };
+  env20539[0] = a0;
+  env20539[1] = a1;
+  const r11 = {};
+  r11[RPCCommands.AUTHENTICATE] = createRPCCommand(RPCCommands.AUTHENTICATE, {
+    handler: (a0) => {
+      let r51, IDENTIFY;
+      let env27517;
+      const r6 = env27517 = {
+        $parent: env20539
+      };
+      const socket2 = a0.socket;
+      env27517[0] = socket2;
+      const signal = a0.signal;
+      env27517[1] = signal;
+      const access_token = a0.args.access_token;
+      env27517[2] = void 0;
+      env27517[3] = void 0;
+      env27517[4] = void 0;
+      if (access_token == null && socket2.transport === TransportTypes.IPC) {
+        const id = socket2.application.id;
+        env27517[2] = id;
+        if (id == null) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_COMMAND
+          }, "No application.");
+        }
+        L12: {
+          IDENTIFY = OAuth2Scopes.IDENTIFY;
+          env27517[3] = IDENTIFY;
+          env27517[4] = () => {};
+          const r50 = Storage.get(c9428_16);
+          const r2 = r50 != null;
+          r51 = void 0;
+          if (r2) {
+            const r53 = r50[id] != null;
+            r51 = void 0;
+            if (r53) {
+              const r54 = r50[id];
+              if (r54.scope === IDENTIFY && !(r54.expires <= Date.now())) {
+                r51 = r54.accessToken;
+                break L12;
+              }
+              delete r50[id];
+              Storage.set(c9428_16, r50);
+              r51 = void 0;
+            }
+          }
+        }
+        return r51 != null ? authenticate(socket2, r51).catch(() => {
+          const r2 = env27517;
+          const client_id = env27517[2];
+          let r15 = Storage.get(c9428_16);
+          if (r15 == null) {
+            r15 = {};
+          }
+          delete r15[client_id];
+          Storage.set(c9428_16, r15);
+          return authorizeWithPrompt({
+            client_id,
+            scope: env27517[3],
+            response_type: "token",
+            signal: env27517[1],
+            isSocketRpcPrivateScope: false
+          }, env20539[0], env20539[1]).then($mk116551(r2));
+        }) : authorizeWithPrompt({
+          client_id: id,
+          scope: IDENTIFY,
+          response_type: "token",
+          signal,
+          isSocketRpcPrivateScope: false
+        }, env20539[0], env20539[1]).then($mk116551(r6));
+      }
+      if (access_token == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_TOKEN
+        }, "No access token provided");
+      }
+      return authenticate(socket2, access_token);
+    }
+  });
+  r11[RPCCommands.AUTHORIZE] = {
+    handler: ({ socket, signal, args }) => {
+      let c27518_1;
+      c27518_1 = void 0;
+      const client_id = args.client_id;
+      if (client_id) {
+        if (socket.authorization.accessToken != null) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_COMMAND
+          }, "Already authenticated");
+        }
+        if (socket.authorization.authing) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_COMMAND
+          }, "Already authing");
+        }
+        socket.authorization.authing = true;
+        if (args.response_type === "token") {
+          socket.authorization.authing = false;
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_COMMAND
+          }, "Authorization response_type \"token\" is not supported");
+        }
+        const isSocketRpcPrivateScope = socket.authorization.scopes.includes(RPC_PRIVATE_SCOPE);
+        c27518_1 = isSocketRpcPrivateScope;
+        if (!isSocketRpcPrivateScope && socket.application.id !== client_id) {
+          socket.authorization.authing = false;
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_CLIENTID
+          }, "Application does not match the connection's");
+        }
+        const scope = args.scopes || args.scope;
+        delete args["scopes"];
+        return authorizeWithPrompt({
+          ...args,
+          scope,
+          signal,
+          isSocketRpcPrivateScope
+        }, env20539[0], env20539[1]).then((result) => {
+          socket.authorization.authing = false;
+          if (result == null) {
+            throw new RPCError({
+              errorCode: RPCErrors.UNKNOWN_ERROR
+            }, "Unknown error occurred");
+          }
+          const uRL = new URL(result);
+          const code = uRL.searchParams.get("code");
+          if (c27518_1) {
+            return {
+              code,
+              location: result
+            };
+          }
+          const r10 = uRL.searchParams.get("error");
+          if (r10 != null && r10 !== "") {
+            let r43 = uRL.searchParams.get("error_description");
+            if (r43 == null) {
+              r43 = "unknown error";
+            }
+            throw new RPCError({
+              errorCode: RPCErrors.OAUTH2_ERROR
+            }, `OAuth2 Error: ${r10}: ${r43}`);
+          }
+          if (code == null) {
+            throw new RPCError({
+              errorCode: RPCErrors.OAUTH2_ERROR
+            }, "OAuth2 Error: Unable to find auth code");
+          }
+          return {
+            code
+          };
+        }).catch((error) => {
+          socket.authorization.authing = false;
+          throw error;
+        });
+      }
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CLIENTID
+      }, "No client id provided");
+    }
+  };
+  return r11;
+};
+export { c9428_17 as AUTHORIZE_PROMPT_THROTTLERS };

modules/rpc/server/commands/activities.tsx

@@ -0,0 +1,58 @@
+// Metro module 13565 (f13566).
+import { ApplicationFlags, RPCErrors, RPCCommands } from "../../../../Constants";
+import { createRPCCommand } from "../../../../_bundle/Module13535";
+import { activityInstanceConnectedParticipantsScope, activityInstanceConnectedParticipants } from "../../helpers/activityInstanceConnectedParticipants";
+import { validatePostMessageTransport, validateApplication } from "../../RPCHelpers";
+import { hasApplicationFlag } from "../../../applications/utils/ApplicationFlagUtils";
+import RPCError from "../../RPCError";
+import getCurrentEmbeddedActivityChannel from "../../helpers/getCurrentEmbeddedActivityChannel";
+import { createProxyTicket } from "../../../activities/EmbeddedActivitiesActionCreators";
+const r22 = {};
+r22[RPCCommands.GET_ACTIVITY_INSTANCE_CONNECTED_PARTICIPANTS] = createRPCCommand(RPCCommands.GET_ACTIVITY_INSTANCE_CONNECTED_PARTICIPANTS, {
+  scope: activityInstanceConnectedParticipantsScope,
+  handler: (a0) => {
+    validatePostMessageTransport(a0.socket.transport);
+    return activityInstanceConnectedParticipants();
+  }
+});
+r22[RPCCommands.REQUEST_PROXY_TICKET_REFRESH] = createRPCCommand(RPCCommands.REQUEST_PROXY_TICKET_REFRESH, {
+  scope: activityInstanceConnectedParticipantsScope,
+  handler: async ({ socket }) => {
+    let value;
+    let c27513_3 = 0;
+    try {
+      validatePostMessageTransport(socket.transport);
+      const r43 = validateApplication(socket.application);
+      if (!hasApplicationFlag(socket.application, ApplicationFlags.EMBEDDED)) {
+        throw new RPCError({
+          errorCode: RPCErrors.UNAUTHORIZED_FOR_APPLICATION
+        }, "This application cannot access this API");
+      }
+      const currentEmbeddedActivityChannel = getCurrentEmbeddedActivityChannel();
+      c27513_3 = 1;
+      value = {};
+      value.ticket = await createProxyTicket(r43, currentEmbeddedActivityChannel?.id);
+      c27513_3 = 0;
+    } catch ($e) {
+      let r8 = $e;
+      if (c27513_3 !== 0) {
+        while (true) {
+          try {
+            c27513_3 = 0;
+            throw new RPCError({
+              errorCode: RPCErrors.UNKNOWN_ERROR
+            }, "Failed to create proxy ticket");
+          } catch ($e) {
+            r8 = $e;
+            if (c27513_3 === 0) {
+              break;
+            }
+          }
+        }
+      }
+      throw r8;
+    }
+    return value;
+  }
+});
+export default r22;

modules/rpc/server/commands/application.tsx

@@ -0,0 +1,64 @@
+// Metro module 13526 (f13527).
+import ApplicationStore from "../../../applications/ApplicationStore";
+import { RPC_LOCAL_SCOPE } from "../../Constants";
+import { ApplicationFlags, Endpoints, RPCErrors, RPCCommands } from "../../../../Constants";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import { validatePostMessageTransport, validateApplication } from "../../RPCHelpers";
+import getCurrentEmbeddedActivityChannel from "../../helpers/getCurrentEmbeddedActivityChannel";
+import { hasApplicationFlag } from "../../../applications/utils/ApplicationFlagUtils";
+import RPCError from "../../RPCError";
+import { getActiveAnalyticsSessionIDs } from "../../../activities/EmbeddedActivitiesManager";
+import AnalyticsUtils from "../../../../utils/AnalyticsUtils";
+import { HTTP } from "../../../../_bundle/sendRequest";
+import { isTestModeForApplication } from "../../../game_store/TestModeUtils";
+const r24 = {};
+r24[RPCCommands.SEND_ANALYTICS_EVENT] = {
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    event_name: a0.string().required(),
+    event_properties: createRpcJoiSchemaObject(a0).required()
+  }),
+  handler: ({ socket, args }) => {
+    const { event_name, event_properties } = args;
+    validatePostMessageTransport(socket.transport);
+    validateApplication(socket.application);
+    const id = socket.application.id;
+    const currentEmbeddedActivityChannel = getCurrentEmbeddedActivityChannel();
+    const activity_guild_id = currentEmbeddedActivityChannel == null ? void 0 : currentEmbeddedActivityChannel.getGuildId();
+    if (hasApplicationFlag(ApplicationStore.getApplication(id), ApplicationFlags.EMBEDDED_FIRST_PARTY)) {
+      AnalyticsUtils.track(event_name, {
+        ...{
+          activity_application_id: id,
+          activity_channel_type: currentEmbeddedActivityChannel?.type,
+          activity_guild_id,
+          activity_user_session_id: getActiveAnalyticsSessionIDs(id)?.activityUserSessionId
+        },
+        ...event_properties
+      });
+      return void 0;
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, "This application cannot access this API");
+  }
+};
+r24[RPCCommands.GET_APPLICATION_TICKET] = {
+  scope: RPC_LOCAL_SCOPE,
+  handler: (a0) => {
+    const id = a0.socket.application.id;
+    if (id == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "No application.");
+    }
+    return HTTP.post({
+      url: Endpoints.APPLICATION_TICKET(id),
+      body: {
+        test_mode: isTestModeForApplication(id)
+      },
+      retries: 3,
+      oldFormErrors: true,
+      rejectWithError: false
+    }).then((result) => result.body);
+  }
+};
+export default r24;

modules/rpc/server/commands/certifiedDevices.tsx

@@ -0,0 +1,56 @@
+// Metro module 13528 (f13529).
+import * as _Constants from "../../Constants";
+import { RPCErrors, RPCCommands } from "../../../../Constants";
+import { DeviceTypes } from "../../../../_bundle/Module4250";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import RPCError from "../../RPCError";
+import { setCertifiedDevices } from "../../../../actions/CertifiedDeviceActionCreators";
+const { RPC_LOCAL_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const r25 = {};
+const SET_CERTIFIED_DEVICES = RPCCommands.SET_CERTIFIED_DEVICES;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE];
+r25[SET_CERTIFIED_DEVICES] = {
+  scope,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    devices: a0.array().items(createRpcJoiSchemaObject(a0).keys({
+      type: a0.string().required().valid([DeviceTypes.AUDIO_INPUT, DeviceTypes.AUDIO_OUTPUT, DeviceTypes.VIDEO_INPUT]),
+      id: a0.string().required().min(1),
+      vendor: createRpcJoiSchemaObject(a0).required().keys({
+        name: a0.string().min(1),
+        url: a0.string().min(1)
+      }),
+      model: createRpcJoiSchemaObject(a0).required().keys({
+        name: a0.string().min(1),
+        url: a0.string().min(1)
+      }),
+      related: a0.array().items(a0.string().min(1)),
+      echo_cancellation: a0.boolean(),
+      noise_suppression: a0.boolean(),
+      automatic_gain_control: a0.boolean(),
+      hardware_mute: a0.boolean()
+    }))
+  }),
+  handler: (a0) => {
+    const socket = a0.socket;
+    const devices = a0.args.devices;
+    if (socket.application.id == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "No application.");
+    }
+    setCertifiedDevices(socket.application.id, devices.map((device) => ({
+      type: device.type,
+      id: device.id,
+      vendor: device.vendor,
+      model: device.model,
+      related: device.related.filter((c30635_0) => devices.some((device) => device.id === c30635_0)),
+      echoCancellation: device.echo_cancellation,
+      noiseSuppression: device.noise_suppression,
+      automaticGainControl: device.automatic_gain_control,
+      hardwareMute: device.hardware_mute
+    })));
+  }
+};
+export default r25;

modules/rpc/server/commands/channels.tsx

@@ -0,0 +1,217 @@
+// Metro module 13530 (f13531).
+import { isTextChannel, isVoiceChannel } from "../../../../records/ChannelRecord";
+import ChannelStore from "../../../../stores/ChannelStore";
+import GuildStore from "../../../../stores/GuildStore";
+import PermissionStore from "../../../../stores/PermissionStore";
+import SelectedChannelStore from "../../../../stores/SelectedChannelStore";
+import VoiceStateStore from "../../../../stores/VoiceStateStore";
+import { RPC_SCOPE_CONFIG } from "../../Constants";
+import { Permissions, RPCErrors, Routes, RPCCommands } from "../../../../Constants";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import RPCError from "../../RPCError";
+import { transformChannel, hasMessageReadPermission } from "../../RPCHelpers";
+import Module12 from "../../../../_bundle/Module12";
+import getCurrentEmbeddedActivityChannel from "../../helpers/getCurrentEmbeddedActivityChannel";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import SelectedChannelActionCreators from "../../../../actions/SelectedChannelActionCreators";
+import { isChannelFull } from "../../../../utils/ChannelUtils";
+import { replaceWith, transitionTo } from "../../../routing/router_utils";
+import InstantInviteActionCreators from "../../../../actions/InstantInviteActionCreators";
+const r38 = {};
+const GET_CHANNEL = RPCCommands.GET_CHANNEL;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.GUILDS, OAuth2Scopes.GUILDS_CHANNELS_READ];
+r38[GET_CHANNEL] = {
+  scope,
+  handler: (a0) => {
+    const channel_id4 = a0.args.channel_id;
+    const socket3 = a0.socket;
+    const channel = ChannelStore.getChannel(channel_id4);
+    if (channel == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, `Invalid channel id: ${channel_id4}`);
+    }
+    if (channel.isPrivate()) {
+      const scopes = socket3.authorization.scopes;
+      if (!scopes.includes(OAuth2Scopes.RPC) && !scopes.includes(OAuth2Scopes.DM_CHANNELS_READ)) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_PERMISSIONS
+        }, "Invalid scope");
+      }
+    }
+    return transformChannel(channel, hasMessageReadPermission(channel, socket3.application.id, socket3.authorization.scopes));
+  }
+};
+r38[RPCCommands.GET_CHANNELS] = {
+  scope: OAuth2Scopes.RPC,
+  handler: (a0) => {
+    let guild;
+    const guild_id = a0.args.guild_id;
+    guild = void 0;
+    const r18 = Module12.values(ChannelStore.loadAllGuildAndPrivateChannelsFromDisk());
+    let r19 = r18;
+    if (guild_id) {
+      guild = GuildStore.getGuild(guild_id);
+      if (guild == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_GUILD
+        }, `Invalid guild id: ${guild_id}`);
+      }
+      r19 = r18.filter((item) => item.guild_id === guild.id);
+    }
+    return {
+      channels: r19.filter((item) => PermissionStore.can(Permissions.VIEW_CHANNEL, item)).map((item) => ({
+        id: item.id,
+        name: item.name,
+        type: item.type
+      }))
+    };
+  }
+};
+const GET_CHANNEL_PERMISSIONS = RPCCommands.GET_CHANNEL_PERMISSIONS;
+const scope2 = {};
+scope2[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.GUILDS_MEMBERS_READ, OAuth2Scopes.GUILDS_CHANNELS_READ];
+r38[GET_CHANNEL_PERMISSIONS] = {
+  scope: scope2,
+  handler: () => {
+    const currentEmbeddedActivityChannel = getCurrentEmbeddedActivityChannel();
+    if (currentEmbeddedActivityChannel == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, "Invalid channel");
+    }
+    return {
+      permissions: PermissionStore.computePermissions(currentEmbeddedActivityChannel)
+    };
+  }
+};
+r38[RPCCommands.SELECT_VOICE_CHANNEL] = {
+  scope: OAuth2Scopes.RPC,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    channel_id: a0.string().allow(null),
+    timeout: a0.number().min(0).max(60),
+    force: a0.boolean(),
+    navigate: a0.boolean()
+  }),
+  handler: ({ server, socket, args }) => {
+    const { channel_id, timeout = 0, force = false, navigate = false } = args;
+    let c20515_2 = navigate;
+    if (channel_id) {
+      const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
+      if (voiceChannelId != null && voiceChannelId !== channel_id && force === false) {
+        throw new RPCError({
+          errorCode: RPCErrors.SELECT_VOICE_FORCE_REQUIRED
+        }, "User is already joined to a voice channel.");
+      }
+      return server.storeWait(socket, () => ChannelStore.getChannel(channel_id), timeout).catch(() => {
+        throw new RPCError({
+          errorCode: RPCErrors.SELECT_CHANNEL_TIMED_OUT
+        }, "Request to select voice channel timed out.");
+      }).then((result) => {
+        if (result == null) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_CHANNEL
+          }, `Invalid channel id: ${channel_id}`);
+        }
+        if (isVoiceChannel(result.type)) {
+          return Promise.all([Promise.resolve(result), transformChannel(result, hasMessageReadPermission(result, socket.application.id, socket.authorization.scopes))]);
+        }
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_CHANNEL
+        }, "Channel is not a voice channel");
+      }).then((result) => {
+        const [r27, r28] = result;
+        if (r28.guild_id) {
+          if (isChannelFull(r27, VoiceStateStore, GuildStore)) {
+            throw new RPCError({
+              errorCode: RPCErrors.INVALID_CHANNEL
+            }, "Channel is full");
+          }
+          if (!PermissionStore.can(Permissions.CONNECT, r27)) {
+            throw new RPCError({
+              errorCode: RPCErrors.INVALID_PERMISSIONS
+            }, "Connect permission required to join channel");
+          }
+        }
+        SelectedChannelActionCreators.selectVoiceChannel(r27.id);
+        if (c20515_2) {
+          replaceWith(Routes.CHANNEL(r27.guild_id, r27.id));
+        }
+        return r28;
+      });
+    }
+    SelectedChannelActionCreators.selectVoiceChannel(null);
+    return null;
+  }
+};
+const GET_SELECTED_VOICE_CHANNEL = RPCCommands.GET_SELECTED_VOICE_CHANNEL;
+const scope3 = {};
+scope3[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ];
+r38[GET_SELECTED_VOICE_CHANNEL] = {
+  scope: scope3,
+  handler: ({ socket: socket3 }) => {
+    const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
+    const r5 = voiceChannelId != null ? ChannelStore.getChannel(voiceChannelId) : null;
+    return r5 != null ? transformChannel(r5, hasMessageReadPermission(r5, socket3.application.id, socket3.authorization.scopes)) : null;
+  }
+};
+r38[RPCCommands.SELECT_TEXT_CHANNEL] = {
+  scope: OAuth2Scopes.RPC,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    channel_id: a0.string().allow(null),
+    timeout: a0.number().min(0).max(60)
+  }),
+  handler: ({ server, socket: socket2, args }) => {
+    let r18;
+    const { channel_id: channel_id2, timeout = 0 } = args;
+    if (channel_id2) {
+      r18 = server.storeWait(socket2, () => ChannelStore.getChannel(channel_id2), timeout).catch(() => {
+        throw new RPCError({
+          errorCode: RPCErrors.SELECT_CHANNEL_TIMED_OUT
+        }, "Request to select text channel timed out.");
+      }).then((result) => {
+        if (result == null) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_CHANNEL
+          }, `Invalid channel id: ${channel_id2}`);
+        }
+        if (isTextChannel(result.type)) {
+          return Promise.all([Promise.resolve(result), transformChannel(result, hasMessageReadPermission(result, socket2.application.id, socket2.authorization.scopes))]);
+        }
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_CHANNEL
+        }, "Channel is not a text channel");
+      }).then((result) => {
+        const [r25, r26] = result;
+        if (r26.guild_id && !PermissionStore.can(Permissions.VIEW_CHANNEL, r25)) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_CHANNEL
+          }, "No permission to see channel");
+        }
+        if (r26.guild_id) {
+          replaceWith(Routes.CHANNEL(r26.guild_id, r25.id));
+        } else {
+          SelectedChannelActionCreators.selectPrivateChannel(r25.id);
+        }
+        return r26;
+      });
+    } else {
+      transitionTo(Routes.ME);
+      r18 = null;
+    }
+    return r18;
+  }
+};
+r38[RPCCommands.CREATE_CHANNEL_INVITE] = {
+  scope: OAuth2Scopes.RPC,
+  handler: ({ args }) => {
+    const { channel_id: channel_id3, ...rest } = args;
+    return InstantInviteActionCreators.createInvite(channel_id3, rest, "RPC").catch(() => {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_PERMISSIONS
+      }, `Unable to generate an invite for ${channel_id3}. Does this user have permissions?`);
+    });
+  }
+};
+export default r38;

modules/rpc/server/commands/config.tsx

@@ -0,0 +1,38 @@
+// Metro module 13531 (f13532).
+import { TransportTypes, RPC_AUTHENTICATED_SCOPE } from "../../Constants";
+import { RPCErrors, RPCCommands } from "../../../../Constants";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import RPCError from "../../RPCError";
+import Dispatcher from "../../../../Dispatcher";
+const r20 = {};
+r20[RPCCommands.SET_CONFIG] = {
+  scope: RPC_AUTHENTICATED_SCOPE,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    use_interactive_pip: a0.boolean()
+  }),
+  handler: (a0) => {
+    const socket = a0.socket;
+    const use_interactive_pip = a0.args.use_interactive_pip;
+    if (socket.transport !== TransportTypes.POST_MESSAGE) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, `command not available from "${socket.transport} transport`);
+    }
+    if (socket.application.id == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "invalid application");
+    }
+    Dispatcher.dispatch({
+      type: "EMBEDDED_ACTIVITY_SET_CONFIG",
+      applicationId: socket.application.id,
+      config: {
+        useInteractivePIP: use_interactive_pip
+      }
+    });
+    return Promise.resolve({
+      use_interactive_pip
+    });
+  }
+};
+export default r20;

modules/rpc/server/commands/crossPlatformRPCCommands.tsx

@@ -0,0 +1,50 @@
+// Metro module 13525 (f13526).
+import application from "./application";
+import certifiedDevices from "./certifiedDevices";
+import channels from "./channels";
+import config from "./config";
+import guilds from "./guilds";
+import images from "./images";
+import invites from "./invites";
+import links from "./links";
+import logs from "./logs";
+import networking from "./networking";
+import providers from "./providers";
+import relationships from "./relationships";
+import setActivity from "./setActivity";
+import setOrientationLockState from "./setOrientationLockState";
+import store from "./store";
+import subscriptions from "./subscriptions";
+import users from "./users";
+import userSettings from "./userSettings";
+import platformBehaviors from "./platformBehaviors";
+import soundboard from "./soundboard";
+import activities from "./activities";
+import quests from "./quests";
+import voiceChannelChat from "./voiceChannelChat";
+const r13 = {
+  ...application,
+  ...certifiedDevices,
+  ...channels,
+  ...config,
+  ...guilds,
+  ...images,
+  ...invites,
+  ...links,
+  ...logs,
+  ...networking,
+  ...providers,
+  ...relationships,
+  ...setActivity,
+  ...setOrientationLockState,
+  ...store,
+  ...subscriptions,
+  ...users,
+  ...userSettings,
+  ...platformBehaviors,
+  ...soundboard,
+  ...activities,
+  ...quests,
+  ...voiceChannelChat
+};
+export { r13 as crossPlatformCommands };

modules/rpc/server/commands/guilds.tsx

@@ -0,0 +1,57 @@
+// Metro module 13532 (f13533).
+import { getGuildIconURL } from "../../../../records/GuildRecord";
+import GuildStore from "../../../../stores/GuildStore";
+import { RPCErrors, RPCCommands } from "../../../../Constants";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import RPCError from "../../RPCError";
+const r21 = {};
+r21[RPCCommands.GET_GUILD] = {
+  scope: OAuth2Scopes.RPC,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    guild_id: a0.string(),
+    timeout: a0.number().min(0).max(60)
+  }),
+  handler: ({ socket, server, args }) => {
+    const { guild_id, timeout = 0 } = args;
+    return server.storeWait(socket, () => GuildStore.getGuild(guild_id), timeout).catch(() => {
+      throw new RPCError({
+        errorCode: RPCErrors.GET_GUILD_TIMED_OUT
+      }, "Request to get guild timed out.");
+    }).then((result) => {
+      if (result == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_GUILD
+        }, `Invalid guild id: ${guild_id}`);
+      }
+      let icon_url = getGuildIconURL(result, 128);
+      if (icon_url == null) {
+        icon_url = null;
+      }
+      return {
+        id: result.id,
+        name: result.name,
+        icon_url,
+        members: [],
+        vanity_url_code: result.vanityURLCode
+      };
+    });
+  }
+};
+r21[RPCCommands.GET_GUILDS] = {
+  scope: OAuth2Scopes.RPC,
+  handler: () => ({
+    guilds: GuildStore.getGuildsArray().map((item) => {
+      let icon_url = getGuildIconURL(item, 128);
+      if (icon_url == null) {
+        icon_url = null;
+      }
+      return {
+        id: item.id,
+        name: item.name,
+        icon_url
+      };
+    })
+  })
+};
+export default r21;

modules/rpc/server/commands/images.tsx

@@ -0,0 +1,42 @@
+// Metro module 13533 (f13534).
+import UserStore from "../../../../stores/UserStore";
+import { RPC_LOCAL_SCOPE } from "../../Constants";
+import { RPCErrors, RPCCommands } from "../../../../Constants";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import AvatarUtils from "../../../../utils/AvatarUtils";
+import RPCError from "../../RPCError";
+import { readFileAsBase64 } from "../../../../utils/ImageUtils";
+const r21 = {};
+r21[RPCCommands.GET_IMAGE] = {
+  scope: RPC_LOCAL_SCOPE,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    type: a0.string().required().valid(["user"]),
+    id: a0.string().required(),
+    format: a0.string().required().valid(["png", "webp", "jpg"]),
+    size: a0.number().required().valid([16, 32, 64, 128, 256, 512, 1024])
+  }),
+  handler: ({ args }) => {
+    const { type, id, format = "png", size = 128 } = args;
+    let r6 = void 0;
+    if (type === "user") {
+      const user = UserStore.getUser(id);
+      if (user == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_USER
+        }, `Invalid user id: ${id}`);
+      }
+      const userAvatarURL = AvatarUtils.getUserAvatarURL(user, false, size, format);
+      const CDN_HOST = window.GLOBAL_ENV.CDN_HOST;
+      r6 = CDN_HOST != null && userAvatarURL.indexOf(CDN_HOST) !== -1 ? userAvatarURL + "&_=" : userAvatarURL;
+    }
+    if (r6 == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "No valid type.");
+    }
+    return fetch(r6).then((result) => result.blob()).then((result) => readFileAsBase64(result)).then((result) => ({
+      data_url: result
+    }));
+  }
+};
+export default r21;

modules/rpc/server/commands/invites.tsx

@@ -0,0 +1,97 @@
+// Metro module 13534 (f13535).
+import EmbeddedActivitiesStore from "../../../activities/EmbeddedActivitiesStore";
+import ChannelStore from "../../../../stores/ChannelStore";
+import { RPC_SCOPE_CONFIG } from "../../Constants";
+import { InstantInviteSources } from "../../../../Constants";
+import { RPCErrors, RPCCommands } from "../../../../_bundle/Module505";
+import { createRPCCommand } from "../../../../_bundle/Module13535";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import { RPCError } from "../../../../_bundle/Module10627";
+import { EmbeddedActivityLocationKind } from "../../../../_bundle/Module10648";
+import { validateOpenInviteDialog } from "../../helpers/validateOpenInviteDialog";
+import { ChannelTypes } from "../../../../_bundle/Module692";
+import { sendEmbeddedActivityInviteUser } from "../../../activities/EmbeddedActivitiesActionCreators";
+const r32 = {};
+const { INVITE_USER_EMBEDDED, INVITE_USER_EMBEDDED: INVITE_USER_EMBEDDED2 } = RPCCommands;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.DM_CHANNELS_MESSAGES_WRITE, OAuth2Scopes.ACTIVITIES_INVITES_WRITE];
+r32[INVITE_USER_EMBEDDED] = createRPCCommand(INVITE_USER_EMBEDDED2, {
+  scope,
+  handler: async ({ socket, args }) => {
+    let r80;
+    const { user_id, content } = args;
+    let c27496_2 = 0;
+    const r20 = "No eligible activity for application. Ensure an activity was set using setActivity.";
+    try {
+      const id = socket.application.id;
+      if (id == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_COMMAND
+        }, "No application.");
+      }
+      const connectedActivityLocation = EmbeddedActivitiesStore.getConnectedActivityLocation();
+      if (connectedActivityLocation == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.NO_ELIGIBLE_ACTIVITY
+        }, r20);
+      }
+      L19: {
+        const kind = connectedActivityLocation.kind;
+        if (EmbeddedActivityLocationKind.GUILD_CHANNEL !== kind && EmbeddedActivityLocationKind.GUILD_CHANNEL_MESSAGE !== kind) {
+          if (EmbeddedActivityLocationKind.PRIVATE_CHANNEL !== kind && EmbeddedActivityLocationKind.PRIVATE_CHANNEL_MESSAGE !== kind) {
+            throw new RPCError({
+              errorCode: RPCErrors.NO_ELIGIBLE_ACTIVITY
+            }, "Unsupported activity location");
+          }
+          const channel = ChannelStore.getChannel(connectedActivityLocation.channel_id);
+          if (channel == null) {
+            throw new RPCError({
+              errorCode: RPCErrors.INVALID_CHANNEL
+            }, "Invalid channel");
+          }
+          const type = channel.type;
+          const DM = ChannelTypes.DM;
+          r80 = channel;
+          if (type !== DM) {
+            break L19;
+          }
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_CHANNEL
+          }, "Cannot send invite to a DM");
+        }
+        r80 = validateOpenInviteDialog().channel;
+      }
+      c27496_2 = 1;
+      await sendEmbeddedActivityInviteUser({
+        channelId: r80.id,
+        applicationId: id,
+        userId: user_id,
+        prefixedContent: content,
+        location: "RPC_ACTIVITY_INVITE_USER",
+        inviteAnalyticsMetadata: {
+          source: InstantInviteSources.ACTIVITY_INVITE
+        }
+      });
+      c27496_2 = 0;
+    } catch ($e) {
+      let r37 = $e;
+      if (c27496_2 !== 0) {
+        while (true) {
+          try {
+            c27496_2 = 0;
+            throw new RPCError({
+              errorCode: RPCErrors.UNKNOWN_ERROR
+            }, "Failed to invite user");
+          } catch ($e) {
+            r37 = $e;
+            if (c27496_2 === 0) {
+              break;
+            }
+          }
+        }
+      }
+      throw r37;
+    }
+  }
+});
+export default r32;

modules/rpc/server/commands/links.tsx

@@ -0,0 +1,205 @@
+// Metro module 13539 (f13540).
+import EmbeddedActivitiesStore from "../../../activities/EmbeddedActivitiesStore";
+import ApplicationStore from "../../../applications/ApplicationStore";
+import * as _Constants from "../../Constants";
+import { RPCCommands, PopoutWindowKeys, AnalyticEvents, RPCErrors, UserSettingsSections, ApplicationFlags } from "../../../../Constants";
+import { AM_HARMONY_PRD_APPLICATION_ID, AM_HARMONY_STG_APPLICATION_ID } from "../../../activities/Constants";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import { validatePostMessageTransport, validateApplication } from "../../RPCHelpers";
+import { isPlatformEmbedded } from "../../../../utils/PlatformUtils";
+import { shouldOpenActivityInPopoutWindow } from "../../../activities/ActivityPopoutUtils.native";
+import CrossPlatformNativeUtils_native from "../../../../utils/CrossPlatformNativeUtils.native";
+import { getEmbeddedActivityLocationChannelId } from "../../../activities/utils/embeddedActivityLocationUtils";
+import { fetchIsLinkTrusted } from "../../../activities/utils/fetchIsLinkTrusted";
+import openURL from "../../../../lib/openURL";
+import AnalyticsUtils from "../../../../utils/AnalyticsUtils";
+import { handleClick } from "../../../../utils/MaskedLinkUtils";
+import { getActivitiesModalContextKey } from "../../../activities/getActivitiesModalContextKey.native";
+import RPCError from "../../RPCError";
+import { openUserSettings } from "../../../user_settings/core/native/openUserSettings";
+import { createRPCCommand } from "../../../../_bundle/Module13535";
+import { hasApplicationFlag } from "../../../applications/utils/ApplicationFlagUtils";
+import { openActivityShareLinkModal } from "../../../activities/openActivityShareLinkModal.native";
+function $mk116534($env) {
+  return (a0) => {
+    const r7 = $env;
+    let env31688 = {
+      $parent: $env
+    };
+    env31688[0] = a0;
+    return handleClick({
+      href: r7[0],
+      shouldConfirm: true,
+      onConfirm: () => {
+        const r2 = env31688.$parent.$parent.$parent;
+        const r4 = r2[1];
+        const r3 = r2[2];
+        const r9 = r4(r3[13]);
+        const url = env31688.$parent[0];
+        r9(url);
+        r4(r3[14]).track(r2[10].RPC_OPEN_EXTERNAL_LINK_CALLED, {
+          application_id: env31688.$parent.$parent[0].application?.id,
+          url,
+          opened: true
+        });
+        (0, env31688[0])({
+          opened: true
+        });
+      },
+      onCancel: () => {
+        const r2 = env31688.$parent.$parent.$parent;
+        (0, r2[1])(r2[2][14]).track(r2[10].RPC_OPEN_EXTERNAL_LINK_CALLED, {
+          application_id: env31688.$parent.$parent[0].application?.id,
+          url: env31688.$parent[0],
+          opened: false
+        });
+        (0, env31688[0])({
+          opened: false
+        });
+      }
+    }, void 0, void 0, getActivitiesModalContextKey({
+      application: r7[1],
+      channelId: r7[2]
+    }));
+  };
+}
+let env9399 = {};
+const { RPC_AUTHENTICATED_SCOPE, RPC_EMBEDDED_APP_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const c9399_11 = new Set([AM_HARMONY_PRD_APPLICATION_ID, AM_HARMONY_STG_APPLICATION_ID]);
+const r45 = {};
+const OPEN_EXTERNAL_LINK = RPCCommands.OPEN_EXTERNAL_LINK;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE, RPC_EMBEDDED_APP_SCOPE];
+r45[OPEN_EXTERNAL_LINK] = {
+  scope,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    url: a0.string().required()
+  }),
+  handler: async (a0) => {
+    let r130;
+    let env20521 = {
+      $parent: env9399
+    };
+    env20521[0] = a0.socket;
+    env20521[1] = a0.args.url;
+    let c27497_0, c27497_1, c27497_2;
+    let c27497_3 = 0;
+    const r13 = env20521;
+    try {
+      let env30636;
+      c27497_1 = r13;
+      const r20 = env30636 = {
+        $parent: r13
+      };
+      c27497_0 = r20;
+      env30636[0] = void 0;
+      env30636[1] = void 0;
+      env30636[2] = void 0;
+      validatePostMessageTransport(env20521[0].transport);
+      const currentEmbeddedActivity = EmbeddedActivitiesStore.getCurrentEmbeddedActivity();
+      c27497_3 = 1;
+      const r49 = new URL(env20521[1]).toString();
+      env30636[0] = r49;
+      if (isPlatformEmbedded) {
+        CrossPlatformNativeUtils_native.focus(shouldOpenActivityInPopoutWindow() ? PopoutWindowKeys.ACTIVITY_POPOUT : null, true);
+      }
+      const application = ApplicationStore.getApplication(env20521[0].application?.id);
+      env30636[1] = application;
+      env30636[2] = getEmbeddedActivityLocationChannelId(currentEmbeddedActivity?.location);
+      const isLinkTrusted = await fetchIsLinkTrusted(application?.id, r49);
+      const r105 = c27497_0;
+      if (isLinkTrusted) {
+        openURL(env30636[0]);
+        AnalyticsUtils.track(AnalyticEvents.RPC_OPEN_EXTERNAL_LINK_CALLED, {
+          application_id: env20521[0].application?.id,
+          url: env30636[0],
+          opened: true
+        });
+        r130 = Promise.resolve({
+          opened: true
+        });
+      } else {
+        r130 = new Promise($mk116534(r105));
+      }
+      c27497_3 = 0;
+    } catch ($e) {
+      const r35 = $e;
+      let r8 = r35;
+      c27497_2 = r35;
+      if (c27497_3 !== 0) {
+        while (true) {
+          try {
+            c27497_3 = 0;
+            throw new RPCError({
+              errorCode: RPCErrors.INVALID_COMMAND
+            }, `Invalid URL: ${env20521[1]}`);
+          } catch (r142) {
+            r8 = r142;
+            c27497_2 = r142;
+            if (c27497_3 === 0) {
+              break;
+            }
+          }
+        }
+      }
+      throw r8;
+    }
+    return r130;
+  }
+};
+const NAVIGATE_TO_CONNECTIONS = RPCCommands.NAVIGATE_TO_CONNECTIONS;
+const scope2 = {};
+scope2[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE];
+r45[NAVIGATE_TO_CONNECTIONS] = {
+  validation: (a0) => createRpcJoiSchemaObject(a0),
+  scope: scope2,
+  handler: ({ socket }) => {
+    validatePostMessageTransport(socket.transport);
+    if (c9399_11.has(validateApplication(socket.application))) {
+      (0, openUserSettings)({
+        screen: UserSettingsSections.CONNECTIONS
+      });
+      return void 0;
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.UNAUTHORIZED_FOR_APPLICATION
+    }, "Command not available for this application");
+  }
+};
+const { SHARE_LINK, SHARE_LINK: SHARE_LINK2 } = RPCCommands;
+const scope3 = {};
+scope3[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE];
+r45[SHARE_LINK] = createRPCCommand(SHARE_LINK2, {
+  scope: scope3,
+  handler: ({ socket, args }) => {
+    const { custom_id, message, link_id } = args;
+    validatePostMessageTransport(socket.transport);
+    const applicationId = validateApplication(socket.application);
+    if (applicationId == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "No application.");
+    }
+    if (hasApplicationFlag(socket.application, ApplicationFlags.EMBEDDED)) {
+      return new Promise((c27498_0) => {
+        openActivityShareLinkModal({
+          applicationId,
+          customId: custom_id,
+          linkId: link_id,
+          message,
+          onShare: function onShare(a0, a1) {
+            c27498_0({
+              success: a1 ? a1 : a0,
+              didCopyLink: a1,
+              didSendMessage: a0
+            });
+          }
+        });
+      });
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, "This application cannot access this API");
+  }
+});
+export default r45;

modules/rpc/server/commands/logs.tsx

@@ -0,0 +1,30 @@
+// Metro module 13545 (f13546).
+import { RPCCommands, RPC_APPLICATION_LOGGING_CATEGORY } from "../../../../Constants";
+import Logger from "../../../debug/Logger";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import { validatePostMessageTransport } from "../../RPCHelpers";
+let c9404_3 = new Logger(RPC_APPLICATION_LOGGING_CATEGORY);
+const r25 = {};
+r25[RPCCommands.CAPTURE_LOG] = {
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    level: a0.string().max(10).required(),
+    message: a0.string().max(1000).required()
+  }),
+  handler: ({ socket, args }) => {
+    const { level, message } = args;
+    validatePostMessageTransport(socket.transport);
+    const r21 = `${socket.application.id} - ${message}`;
+    if (level === "log") {
+      c9404_3.log(r21);
+    } else if (level === "warn") {
+      c9404_3.warn(r21);
+    } else if (level === "debug") {
+      c9404_3.verbose(r21);
+    } else if (level === "info") {
+      c9404_3.info(r21);
+    } else if (level === "error") {
+      c9404_3.error(r21);
+    }
+  }
+};
+export default r25;

modules/rpc/server/commands/networking.tsx

@@ -0,0 +1,49 @@
+// Metro module 13546 (f13547).
+import { RPC_LOCAL_SCOPE } from "../../Constants";
+import { AnalyticEvents, Endpoints, RPCCommands } from "../../../../Constants";
+import { HTTP } from "../../../../_bundle/sendRequest";
+import AnalyticsUtils from "../../../../utils/AnalyticsUtils";
+const r22 = {};
+r22[RPCCommands.GET_NETWORKING_CONFIG] = {
+  scope: RPC_LOCAL_SCOPE,
+  handler: () => Promise.all([HTTP.get({
+    url: location.protocol + window.GLOBAL_ENV.NETWORKING_ENDPOINT,
+    retries: 3,
+    rejectWithError: false
+  }).then((result) => result.body.address), HTTP.post({
+    url: Endpoints.NETWORKING_TOKEN,
+    retries: 3,
+    oldFormErrors: true,
+    rejectWithError: false
+  }).then((result) => result.body.token)]).then((result) => {
+    const [address, token] = result;
+    return {
+      address,
+      token
+    };
+  })
+};
+r22[RPCCommands.NETWORKING_SYSTEM_METRICS] = {
+  scope: RPC_LOCAL_SCOPE,
+  handler: ({ socket, args }) => {
+    args.application_id = socket.application.id;
+    AnalyticsUtils.track(AnalyticEvents.NETWORKING_SYSTEM_METRICS, args);
+  }
+};
+r22[RPCCommands.NETWORKING_PEER_METRICS] = {
+  scope: RPC_LOCAL_SCOPE,
+  handler: ({ socket, args }) => {
+    args.application_id = socket.application.id;
+    AnalyticsUtils.track(AnalyticEvents.NETWORKING_PEER_METRICS, args);
+  }
+};
+r22[RPCCommands.NETWORKING_CREATE_TOKEN] = {
+  scope: RPC_LOCAL_SCOPE,
+  handler: () => HTTP.post({
+    url: Endpoints.NETWORKING_TOKEN,
+    retries: 1,
+    oldFormErrors: true,
+    rejectWithError: false
+  }).then((result) => result.body)
+};
+export default r22;

modules/rpc/server/commands/platformBehaviors.tsx

@@ -0,0 +1,9 @@
+// Metro module 13563 (f13564).
+import { RPCCommands } from "../../../../_bundle/Module505";
+const r13 = {};
+r13[RPCCommands.GET_PLATFORM_BEHAVIORS] = {
+  handler: () => ({
+    iosKeyboardResizesView: true
+  })
+};
+export default r13;

modules/rpc/server/commands/providers.tsx

@@ -0,0 +1,206 @@
+// Metro module 13547 (f13548).
+import ConnectedAccountsStore from "../../../../stores/ConnectedAccountsStore";
+import * as _Constants from "../../Constants";
+import { PlatformTypes, ComponentActions, AnalyticsLocations } from "../../../../Constants";
+import * as _Constants3 from "../../../activities/Constants";
+import { RPCCommands, RPCErrors } from "../../../../_bundle/Module505";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import { validatePostMessageTransport, validateApplication } from "../../RPCHelpers";
+import Platforms from "../../../../lib/Platforms";
+import RPCError from "../../RPCError";
+import Dispatcher from "../../../../Dispatcher";
+import { ComponentDispatch } from "../../../../utils/ComponentDispatchUtils";
+import authorizeConnection_native from "../../../connections/authorizeConnection.native";
+import ConnectedAccountsActionCreators from "../../../../actions/ConnectedAccountsActionCreators";
+let c9406_3;
+let env9406 = {};
+const { RPC_AUTHENTICATED_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const { AM_HARMONY_PRD_APPLICATION_ID, AM_HARMONY_STG_APPLICATION_ID } = _Constants3;
+const c9406_10 = new Set([AM_HARMONY_PRD_APPLICATION_ID, AM_HARMONY_STG_APPLICATION_ID]);
+const r44 = {};
+const GET_PROVIDER_ACCESS_TOKEN = RPCCommands.GET_PROVIDER_ACCESS_TOKEN;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE];
+r44[GET_PROVIDER_ACCESS_TOKEN] = {
+  scope,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    provider: a0.string().required(),
+    connection_redirect: a0.string()
+  }),
+  handler: (a0) => {
+    let env20525 = {
+      $parent: env9406
+    };
+    const { socket, args } = a0;
+    const provider = args.provider;
+    env20525[0] = provider;
+    env20525[1] = args.connection_redirect;
+    env20525[2] = void 0;
+    validatePostMessageTransport(socket.transport);
+    const r23 = validateApplication(socket.application);
+    const r28 = Platforms.get(provider);
+    env20525[2] = r28;
+    if (r28 == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_PROVIDER
+      }, `Platform not found for provider "${provider}"`);
+    }
+    if (provider !== PlatformTypes.AMAZON_MUSIC) {
+      throw new RPCError({
+        errorCode: RPCErrors.UNAUTHORIZED_FOR_APPLICATION
+      }, "Command not available for this application");
+    }
+    if (c9406_10.has(r23)) {
+      const r43 = Promise;
+      let c20526_0 = async (c30639_0, c30639_1) => {
+        let c30639_2, c30639_3, c30639_4;
+        let c30639_5 = 0;
+        const r13 = void 0;
+        const r12 = env20525;
+        L16: {
+          L14: {
+            try {
+              let env31690;
+              c30639_3 = r13;
+              const r32 = env31690 = {
+                $parent: r12
+              };
+              c30639_2 = r32;
+              env31690[0] = c30639_0;
+              env31690[1] = c30639_1;
+              env31690[2] = void 0;
+              const account = ConnectedAccountsStore.getAccount(null, env20525[0]);
+              if (account == null) {
+                const handleConnectionsUpdate = function handleConnectionsUpdate(a0) {
+                  if (env20525[2] != null) {
+                    let accounts = a0.accounts;
+                    if (accounts == null) {
+                      accounts = [];
+                    }
+                    const r4 = accounts.find((account) => account.type === env20525[2].type);
+                    if (r4 != null) {
+                      (0, env31690[0])({
+                        access_token: r4.access_token
+                      });
+                      Dispatcher.unsubscribe("USER_CONNECTIONS_UPDATE", env31690[3]);
+                      ComponentDispatch.unsubscribe(ComponentActions.CONNECTIONS_CALLBACK_ERROR, env31690[4]);
+                    }
+                  }
+                };
+                env31690[3] = handleConnectionsUpdate;
+                const handleConnectionsCallbackError = function handleConnectionsCallbackError() {
+                  env31690[1](new RPCError({
+                    errorCode: RPCErrors.OAUTH2_ERROR
+                  }, `OAuth2 setup for "${env20525[0]}" failed`));
+                  Dispatcher.unsubscribe("USER_CONNECTIONS_UPDATE", env31690[3]);
+                  ComponentDispatch.unsubscribe(ComponentActions.CONNECTIONS_CALLBACK_ERROR, env31690[4]);
+                };
+                env31690[4] = handleConnectionsCallbackError;
+                Dispatcher.subscribe("USER_CONNECTIONS_UPDATE", handleConnectionsUpdate);
+                ComponentDispatch.subscribe(ComponentActions.CONNECTIONS_CALLBACK_ERROR, handleConnectionsCallbackError);
+                authorizeConnection_native({
+                  platformType: env20525[2].type,
+                  location: AnalyticsLocations.ACTIVITY_RPC,
+                  successRedirect: env20525[1]
+                });
+                break L16;
+              }
+              c30639_5 = 1;
+              const r26 = await ConnectedAccountsActionCreators.refreshAccessToken(env20525[2].type, account.id);
+              const r89 = "Refreshing access token did not return a new access token";
+              env31690[2] = r26;
+              if (env31690[2] == null) {
+                throw new RPCError({
+                  errorCode: RPCErrors.OAUTH2_ERROR
+                }, r89);
+              }
+              (0, env31690[0])({
+                access_token: env31690[2]
+              });
+              c30639_5 = 0;
+            } catch ($e) {
+              const r30 = $e;
+              let r7 = r30;
+              c30639_4 = r30;
+              if (c30639_5 !== 0) {
+                while (true) {
+                  try {
+                    const r119 = c30639_4;
+                    c30639_5 = 0;
+                    (0, env31690[1])(r119);
+                    break L14;
+                  } catch (r116) {
+                    r7 = r116;
+                    c30639_4 = r116;
+                    if (c30639_5 === 0) {
+                      break;
+                    }
+                  }
+                }
+              }
+              throw r7;
+            }
+          }
+          return void 0;
+        }
+      };
+      return new r43(function() {
+        return c20526_0.apply(this, arguments);
+      });
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.UNAUTHORIZED_FOR_APPLICATION
+    }, "Command not available for this application");
+  }
+};
+const MAYBE_GET_PROVIDER_ACCESS_TOKEN = RPCCommands.MAYBE_GET_PROVIDER_ACCESS_TOKEN;
+const scope2 = {};
+scope2[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE];
+c9406_3 = async (c20527_0) => {
+  let c27502_0 = c20527_0.socket;
+  let c27502_1 = c20527_0.args.provider;
+  await void 0;
+  validatePostMessageTransport(c27502_0.transport);
+  let c27502_2 = validateApplication(c27502_0.application);
+  let c27502_3 = Platforms.get(c27502_1);
+  if (c27502_3 == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_PROVIDER
+    }, `Platform not found for provider "${c27502_1}"`);
+  }
+  if (c27502_1 !== PlatformTypes.AMAZON_MUSIC) {
+    throw new RPCError({
+      errorCode: RPCErrors.UNAUTHORIZED_FOR_APPLICATION
+    }, "Command not available for this application");
+  }
+  if (!c9406_10.has(c27502_2)) {
+    throw new RPCError({
+      errorCode: RPCErrors.UNAUTHORIZED_FOR_APPLICATION
+    }, "Command not available for this application");
+  }
+  let c27502_4 = ConnectedAccountsStore.getAccount(null, c27502_1);
+  if (c27502_4 == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.NO_CONNECTION_FOUND
+    }, "No connection found");
+  }
+  let c27502_5 = await ConnectedAccountsActionCreators.refreshAccessToken(c27502_3.type, c27502_4.id);
+  if (c27502_5 == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.OAUTH2_ERROR
+    }, "Refreshing access token did not return a new access token");
+  }
+  return {
+    access_token: c27502_5
+  };
+};
+r44[MAYBE_GET_PROVIDER_ACCESS_TOKEN] = {
+  scope: scope2,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    provider: a0.string().required()
+  }),
+  handler: function() {
+    return c9406_3.apply(this, arguments);
+  }
+};
+export default r44;

modules/rpc/server/commands/quests.tsx

@@ -0,0 +1,99 @@
+// Metro module 13566 (f13567).
+import QuestStore from "../../../quests/QuestStore";
+import { AnalyticEvents, RPCErrors, RPCCommands } from "../../../../Constants";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import { validatePostMessageTransport, validateApplication } from "../../RPCHelpers";
+import { getActivityApplicationId, getPlayActivityApplicationId } from "../../../quests/utils/QuestTaskUtils";
+import RPCError from "../../RPCError";
+import AnalyticsUtils from "../../../../utils/AnalyticsUtils";
+import Dispatcher from "../../../../Dispatcher";
+import { getEligibleQuestsForApplicationId } from "../../../quests/utils/QuestMatchingUtils";
+const r19 = {};
+r19[RPCCommands.GET_QUEST_ENROLLMENT_STATUS] = {
+  scope: OAuth2Scopes.IDENTIFY,
+  handler: (a0) => {
+    const socket = a0.socket;
+    const quest_id = a0.args.quest_id;
+    validatePostMessageTransport(socket.transport);
+    const r22 = validateApplication(socket.application);
+    const quest = QuestStore.getQuest(quest_id);
+    const activityApplicationId = getActivityApplicationId(quest);
+    if (quest != null && activityApplicationId != null && activityApplicationId === r22) {
+      const enrolledAt = quest.userStatus?.enrolledAt;
+      let enrolled_at = quest.userStatus?.enrolledAt;
+      if (enrolled_at == null) {
+        enrolled_at = null;
+      }
+      return {
+        quest_id,
+        is_enrolled: enrolledAt != null,
+        enrolled_at
+      };
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, `Quest not found: ${quest_id}`);
+  }
+};
+r19[RPCCommands.QUEST_START_TIMER] = {
+  scope: OAuth2Scopes.IDENTIFY,
+  handler: (a0) => {
+    const socket = a0.socket;
+    const quest_id = a0.args.quest_id;
+    validatePostMessageTransport(socket.transport);
+    const application_id = validateApplication(socket.application);
+    const quest = QuestStore.getQuest(quest_id);
+    const playActivityApplicationId = getPlayActivityApplicationId(quest);
+    if (quest != null && playActivityApplicationId != null && playActivityApplicationId === application_id) {
+      if (quest.userStatus?.enrolledAt == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_COMMAND
+        }, "User is not enrolled in quest");
+      }
+      AnalyticsUtils.track(AnalyticEvents.RPC_QUEST_START_TIMER_CALLED, {
+        application_id,
+        quest_id
+      });
+      Dispatcher.dispatch({
+        type: "QUEST_APPLICATION_START_TIMER",
+        questId: quest_id,
+        applicationId: application_id
+      });
+      return {
+        success: true
+      };
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, `Quest not found: ${quest_id}`);
+  }
+};
+r19[RPCCommands.GET_QUEST] = {
+  scope: OAuth2Scopes.IDENTIFY,
+  handler: ({ socket }) => {
+    validatePostMessageTransport(socket.transport);
+    const eligibleQuestsForApplicationId = getEligibleQuestsForApplicationId(QuestStore.quests, validateApplication(socket.application), true);
+    if (eligibleQuestsForApplicationId.length === 0) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "No eligible quests found");
+    }
+    return eligibleQuestsForApplicationId.map((item) => {
+      let enrolled_at = item.userStatus?.enrolledAt;
+      if (enrolled_at == null) {
+        enrolled_at = null;
+      }
+      let completed_at = item.userStatus?.completedAt;
+      if (completed_at == null) {
+        completed_at = null;
+      }
+      return {
+        quest_id: item.id,
+        enrolled_at,
+        completed_at,
+        external_cta_url: item.config.ctaConfig.link
+      };
+    }).sort((a, b) => a.enrolled_at == null ? b.enrolled_at == null ? 0 : a.enrolled_at == null ? 1 : b.enrolled_at == null ? -1 : new Date(a.enrolled_at).getTime() - new Date(b.enrolled_at).getTime() : a.enrolled_at == null ? 1 : b.enrolled_at == null ? -1 : new Date(a.enrolled_at).getTime() - new Date(b.enrolled_at).getTime())[0];
+  }
+};
+export default r19;

modules/rpc/server/commands/relationships.tsx

@@ -0,0 +1,42 @@
+// Metro module 13548 (f13549).
+import RelationshipStore from "../../../../stores/RelationshipStore";
+import UserStore from "../../../../stores/UserStore";
+import { RPC_SCOPE_CONFIG } from "../../Constants";
+import { ApplicationFlags, RPCErrors, RelationshipTypes, RPCCommands } from "../../../../Constants";
+import { createRPCCommand } from "../../../../_bundle/Module13535";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import { has, deserialize } from "../../../../_bundle/HighLow";
+import RPCError from "../../RPCError";
+import { transformApplicationRelationship, transformBaseRelationship } from "../../RPCHelpers";
+const r32 = {};
+const { GET_RELATIONSHIPS, GET_RELATIONSHIPS: GET_RELATIONSHIPS2 } = RPCCommands;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RELATIONSHIPS_READ];
+r32[GET_RELATIONSHIPS] = createRPCCommand(GET_RELATIONSHIPS2, {
+  scope,
+  handler: (a0) => {
+    let flags = a0.socket.application.flags;
+    if (flags == null) {
+      flags = 0;
+    }
+    if (has(deserialize(flags), deserialize(ApplicationFlags.DISABLE_RELATIONSHIPS_ACCESS))) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_PERMISSIONS
+      }, "Missing Permissions");
+    }
+    const relationships = [];
+    for (const item of RelationshipStore.getMutableRelationships().entries()) {
+      const [r59, r60] = item;
+      if (r60 !== RelationshipTypes.NONE) {
+        const user = UserStore.getUser(r59);
+        if (user != null) {
+          relationships.push(transformApplicationRelationship(transformBaseRelationship(r60, user), a0.socket.application.id));
+        }
+      }
+    }
+    return {
+      relationships
+    };
+  }
+});
+export default r32;

modules/rpc/server/commands/setActivity.tsx

@@ -0,0 +1,226 @@
+// Metro module 13549 (f13550).
+import ApplicationStore from "../../../applications/ApplicationStore";
+import * as _Constants from "../../Constants";
+import { TransportTypes } from "../../Constants";
+import { ActivityGamePlatforms, ActivityPartyPrivacy, ActivityTypes, AnalyticEvents, RPCErrors, RPCCommands } from "../../../../Constants";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import { StatusDisplayTypes } from "../../../../_bundle/Module9077";
+import RPCError from "../../RPCError";
+import Dispatcher from "../../../../Dispatcher";
+import { computeActivityFlags } from "../../../activities/utils/ActivityFlagUtils";
+import { canLaunchFrame } from "../../../frames/utils/canLaunchFrame";
+import Module12 from "../../../../_bundle/Module12";
+import Durations from "../../../../utils/Durations";
+import { fetchAssetIds } from "../../../../utils/ApplicationAssetUtils";
+import AnalyticsUtils from "../../../../utils/AnalyticsUtils";
+const { RPC_SCOPE_CONFIG, RPC_LOCAL_SCOPE } = _Constants;
+const _excluded = ["1402418171662569542"];
+const r30 = {};
+const SET_ACTIVITY = RPCCommands.SET_ACTIVITY;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_ACTIVITIES_WRITE, RPC_LOCAL_SCOPE];
+r30[SET_ACTIVITY] = {
+  scope,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    pid: a0.number().min(0),
+    activity: createRpcJoiSchemaObject(a0).keys({
+      name: a0.string().min(1).max(128),
+      state: a0.string().min(2).max(128),
+      state_url: a0.string().uri().min(1).max(256),
+      details: a0.string().min(2).max(128),
+      details_url: a0.string().uri().min(1).max(256),
+      timestamps: createRpcJoiSchemaObject(a0).keys({
+        start: a0.number().min(1),
+        end: a0.number().min(1)
+      }),
+      assets: createRpcJoiSchemaObject(a0).keys({
+        large_image: a0.string().min(1).max(300),
+        large_text: a0.string().min(2).max(128),
+        large_url: a0.string().uri().min(1).max(256),
+        small_image: a0.string().min(1).max(300),
+        small_text: a0.string().min(2).max(128),
+        small_url: a0.string().uri().min(1).max(256),
+        invite_cover_image: a0.string().min(1).max(300)
+      }),
+      party: createRpcJoiSchemaObject(a0).keys({
+        id: a0.string().min(2).max(128),
+        size: a0.array().items(a0.number().min(0)).length(2),
+        privacy: a0.number().default(ActivityPartyPrivacy.PRIVATE).valid([ActivityPartyPrivacy.PRIVATE, ActivityPartyPrivacy.PUBLIC])
+      }),
+      secrets: createRpcJoiSchemaObject(a0).keys({
+        match: a0.string().min(2).max(128),
+        join: a0.string().min(2).max(128),
+        spectate: a0.string().min(2).max(128)
+      }),
+      buttons: a0.array().items(createRpcJoiSchemaObject(a0).keys({
+        label: a0.string().min(1).max(32).required(),
+        url: a0.string().uri().min(1).max(512).required()
+      })).min(1).max(2),
+      instance: a0.boolean(),
+      supported_platforms: a0.array().items(a0.string().min(1).max(32)).min(1).max(10),
+      type: a0.number().default(ActivityTypes.PLAYING).valid(ActivityTypes.PLAYING, ActivityTypes.LISTENING, ActivityTypes.WATCHING, ActivityTypes.COMPETING),
+      status_display_type: a0.number().optional().valid(StatusDisplayTypes.NAME, StatusDisplayTypes.STATE, StatusDisplayTypes.DETAILS)
+    }).allow(null)
+  }),
+  handler: (a0) => {
+    let r205;
+    let privacy, assets;
+    const { socket, args } = a0;
+    const { pid, activity } = args;
+    const isSocketConnected = a0.isSocketConnected;
+    privacy = void 0;
+    assets = void 0;
+    if ([TransportTypes.IPC, TransportTypes.WEBSOCKET, TransportTypes.POST_MESSAGE].includes(socket.transport)) {
+      if (pid == null && TransportTypes.IPC === socket.transport) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_COMMAND
+        }, "nonzero pid required");
+      }
+      if (activity == null) {
+        Dispatcher.dispatch({
+          type: "LOCAL_ACTIVITY_UPDATE",
+          socketId: socket.id,
+          pid,
+          activity
+        });
+        return Promise.resolve(activity);
+      }
+      if (!activity.name) {
+        activity.name = socket.application.name;
+      }
+      let id = socket.application.id;
+      activity.application_id = id;
+      const r67 = socket.transport === TransportTypes.POST_MESSAGE;
+      activity.platform = r67 ? ActivityGamePlatforms.EMBEDDED : ActivityGamePlatforms.DESKTOP;
+      if (id == null) {
+        id = void 0;
+      }
+      const application = ApplicationStore.getApplication(id);
+      let instance = activity.instance;
+      if (instance == null) {
+        instance = false;
+      }
+      privacy = activity.party?.privacy;
+      delete activity["instance"];
+      const party = activity.party;
+      if (party != null) {
+        delete party["privacy"];
+      }
+      const flags = computeActivityFlags(activity, instance, r67, application != null && canLaunchFrame(application) && r67, privacy);
+      if (flags > 0) {
+        activity.flags = flags;
+      }
+      assets = activity.assets;
+      const { party: party2, secrets, timestamps, buttons } = activity;
+      if (activity.type == null) {
+        activity.type = ActivityTypes.PLAYING;
+      }
+      if (secrets != null) {
+        const r112 = Module12.values(secrets).filter((item) => !!item);
+        if (party2 != null && Module12.intersection(r112, [party2.id]).length > 0 && !_excluded.includes(socket.application.id)) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_ACTIVITY_SECRET
+          }, "secrets cannot match the party id");
+        }
+        if (Module12.uniq(r112).length < r112.length) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_ACTIVITY_SECRET
+          }, "secrets must be unique");
+        }
+        if (buttons != null) {
+          throw new RPCError({
+            errorCode: RPCErrors.INVALID_ACTIVITY_SECRET
+          }, "secrets cannot currently be sent with buttons");
+        }
+      }
+      const metadata = {};
+      if (buttons != null) {
+        metadata.button_urls = buttons.map((button) => button.url);
+        activity.buttons = buttons.map((button) => button.label);
+      }
+      activity.metadata = metadata;
+      if (timestamps != null) {
+        for (const item of Object.keys(timestamps)) {
+          if (Date.now().toString().length - timestamps[item].toString().length > 2) {
+            timestamps[item] = Math.floor(timestamps[item] * Durations.Millis.SECOND);
+          }
+        }
+      }
+      L48: {
+        if (assets != null) {
+          if (socket.application != null && socket.application.id != null) {
+            r205 = fetchAssetIds(socket.application.id, [assets.large_image, assets.small_image, assets.invite_cover_image]);
+            break L48;
+          }
+          throw new Error();
+        }
+        r205 = Promise.resolve([]);
+      }
+      return r205.then((result) => {
+        const [large_image, small_image, invite_cover_image] = result;
+        if (assets != null) {
+          if (large_image != null) {
+            assets.large_image = large_image;
+          } else {
+            delete assets["large_image"];
+          }
+          if (small_image != null) {
+            assets.small_image = small_image;
+          } else {
+            delete assets["small_image"];
+          }
+          if (invite_cover_image != null) {
+            assets.invite_cover_image = invite_cover_image;
+          } else {
+            delete assets["invite_cover_image"];
+          }
+        }
+        if (isSocketConnected()) {
+          Dispatcher.dispatch({
+            type: "LOCAL_ACTIVITY_UPDATE",
+            socketId: socket.id,
+            pid,
+            activity,
+            partyPrivacy: privacy
+          });
+          const { secrets, party } = activity;
+          let details = activity.details;
+          if (details == null) {
+            details = "";
+          }
+          let state = activity.state;
+          if (state == null) {
+            state = "";
+          }
+          const r62 = {
+            application_id: socket.application.id,
+            type: activity.type,
+            name: activity.name,
+            status_display_type: activity.status_display_type,
+            details,
+            state,
+            has_urls: activity.state_url != null || activity.details_url != null || activity.assets?.large_url != null || activity.assets?.small_url != null
+          };
+          if (secrets != null) {
+            r62.has_match_secret = !!secrets.match;
+            r62.has_join_secret = !!secrets.join;
+          }
+          if (assets != null) {
+            r62.has_images = !!(assets.large_image || assets.small_image || assets.invite_cover_image);
+          }
+          if (party != null) {
+            r62.party_max = party.size != null ? party.size[1] > 0 ? party.size[1] : void 0 : void 0;
+            r62.party_id = party.id;
+          }
+          AnalyticsUtils.track(AnalyticEvents.ACTIVITY_UPDATED, r62);
+          return activity;
+        }
+      });
+    }
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, `command not available from "${socket.transport}" transport`);
+  }
+};
+export default r30;

modules/rpc/server/commands/setOrientationLockState.tsx

@@ -0,0 +1,37 @@
+// Metro module 13550 (f13551).
+import { OrientationLockState } from "../../../activities/Constants";
+import { RPCErrors, RPCCommands } from "../../../../_bundle/Module505";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import Dispatcher from "../../../../Dispatcher";
+import RPCError from "../../RPCError";
+const r19 = {};
+r19[RPCCommands.SET_ORIENTATION_LOCK_STATE] = {
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    lock_state: a0.number().valid(OrientationLockState.UNLOCKED, OrientationLockState.PORTRAIT, OrientationLockState.LANDSCAPE).required(),
+    picture_in_picture_lock_state: a0.number().valid(OrientationLockState.UNLOCKED, OrientationLockState.PORTRAIT, OrientationLockState.LANDSCAPE).allow(null).optional(),
+    grid_lock_state: a0.number().valid(OrientationLockState.UNLOCKED, OrientationLockState.PORTRAIT, OrientationLockState.LANDSCAPE).allow(null).optional()
+  }),
+  handler: ({ socket, args }) => {
+    const { lock_state, picture_in_picture_lock_state, grid_lock_state } = args;
+    const id = socket.application.id;
+    if (id == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "No application.");
+    }
+    Dispatcher.dispatch({
+      type: "FRAME_SET_ORIENTATION_LOCK_STATE",
+      applicationId: id,
+      lockState: lock_state,
+      pictureInPictureLockState: picture_in_picture_lock_state
+    });
+    Dispatcher.dispatch({
+      type: "EMBEDDED_ACTIVITY_SET_ORIENTATION_LOCK_STATE",
+      applicationId: id,
+      lockState: lock_state,
+      pictureInPictureLockState: picture_in_picture_lock_state,
+      gridLockState: grid_lock_state
+    });
+  }
+};
+export default r19;

modules/rpc/server/commands/soundboard.tsx

@@ -0,0 +1,87 @@
+// Metro module 13564 (f13565).
+import SoundboardStore from "../../../soundboard/SoundboardStore";
+import UserStore from "../../../../stores/UserStore";
+import * as _Constants from "../../Constants";
+import { RPCCommands, RPCErrors } from "../../../../_bundle/Module505";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import { maybeFetchSoundboardSounds } from "../../../soundboard/SoundboardActionCreators";
+import { soundboardSoundToAPI } from "../../../soundboard/SoundboardTypes";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import getCurrentVoiceChannel from "../../helpers/getCurrentVoiceChannel";
+import { canUseSoundboardSound, playSound } from "../../../soundboard/SoundboardUtils";
+import RPCError from "../../RPCError";
+import canChannelUseSoundboard from "../../../soundboard/canChannelUseSoundboard";
+import AnalyticsLocation from "../../../app_analytics/AnalyticsLocation";
+function $mk116547($env) {
+  return (a0) => a0.forEach.call(a0, $mk118397($env));
+}
+function $mk118397($env) {
+  return (a0) => {
+    const r3 = $env[1];
+    return r3.push(soundboardSoundToAPI(a0));
+  };
+}
+let env9421 = {};
+const { RPC_LOCAL_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const r30 = {};
+const GET_SOUNDBOARD_SOUNDS = RPCCommands.GET_SOUNDBOARD_SOUNDS;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE];
+r30[GET_SOUNDBOARD_SOUNDS] = {
+  scope,
+  handler: async () => {
+    let env30646;
+    const r21 = env9421;
+    let c27511_1 = r21;
+    const r10 = env30646 = {
+      $parent: r21
+    };
+    let c27511_0 = r10;
+    env30646[0] = void 0;
+    env30646[1] = void 0;
+    await maybeFetchSoundboardSounds();
+    env30646[0] = SoundboardStore.getSounds();
+    env30646[1] = [];
+    env30646[0].forEach($mk116547(c27511_0));
+    return env30646[1];
+  }
+};
+const PLAY_SOUNDBOARD_SOUND = RPCCommands.PLAY_SOUNDBOARD_SOUND;
+const scope2 = {};
+scope2[RPC_SCOPE_CONFIG.ALL] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_WRITE];
+r30[PLAY_SOUNDBOARD_SOUND] = {
+  scope: scope2,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    guild_id: a0.string(),
+    sound_id: a0.string()
+  }),
+  handler: async ({ args }) => {
+    const { guild_id, sound_id } = args;
+    let c27512_1;
+    c27512_1 = void 0;
+    await maybeFetchSoundboardSounds();
+    let c30647_0 = UserStore.getCurrentUser();
+    let c30647_1 = SoundboardStore.getSound(guild_id, sound_id);
+    let c30647_2 = getCurrentVoiceChannel();
+    let c30647_3 = c30647_1 != null && c30647_0 != null && canUseSoundboardSound(c30647_0, c30647_1, c30647_2);
+    if (c30647_2 == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, "Invalid Channel.");
+    }
+    if (!c30647_3) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_SOUND
+      }, "Invalid Sound.");
+    }
+    if (!canChannelUseSoundboard(c30647_2)) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_PERMISSIONS
+      }, "Invalid Permissions.");
+    }
+    if (c30647_1 != null) {
+      playSound(c30647_1, c30647_2.id, [AnalyticsLocation.RPC]);
+    }
+  }
+};
+export default r30;

modules/rpc/server/commands/store.tsx

@@ -0,0 +1,169 @@
+// Metro module 13551 (f13552).
+import * as _Constants from "../../Constants";
+import { RPCCommands, SKUTypes, RPCErrors } from "../../../../Constants";
+import { fetchAllSubscriptionListingsDataForApplication } from "../../../premium_apps/ApplicationSubscriptionsActionCreators";
+import { validateTransportType } from "../../helpers/validateTransportType";
+import RPCError from "../../RPCError";
+import { isTestModeForApplication } from "../../../game_store/TestModeUtils";
+import { fetchTestSKUsForApplication } from "../../../../actions/SKUActionCreators";
+import { fetchAllStoreListingsForApplication } from "../../../../actions/StoreListingActionCreators";
+import { fetchUserEntitlementsForApplication } from "../../../../actions/EntitlementActionCreators";
+import { HermesBuiltin } from "../../../../_hermes/prelude";
+function $mk116539($env) {
+  return (a0) => {
+    if (a0 == null) {
+      return null;
+    }
+    const subscription_listings = a0.subscription_listings;
+    if (subscription_listings == null) {
+      return null;
+    }
+    const r7 = $env;
+    let env31692 = {
+      $parent: $env
+    };
+    const r5 = [];
+    env31692[0] = r5;
+    subscription_listings.forEach((subscription_listing) => {
+      subscription_listing.subscription_plans.forEach((subscription_plan) => {
+        const price = subscription_plan?.price;
+        const r10 = env31692.$parent[1].find((item) => item.id === subscription_plan.sku_id);
+        if (r10 != null) {
+          let release_date = r10.release_date;
+          if (release_date == null) {
+            release_date = null;
+          }
+          env31692[0].push({
+            id: subscription_plan.sku_id,
+            name: r10.name,
+            type: r10.type,
+            price: {
+              amount: price,
+              currency: env31692.$parent.$parent[5].USD
+            },
+            application_id: subscription_listing.application_id,
+            flags: subscription_listing.sku_flags,
+            release_date
+          });
+        }
+      });
+    });
+    r5.filter((item) => item?.price != null).forEach($mk118395(r7));
+  };
+}
+function $mk116541($env) {
+  return (a0) => a0.sku.type !== SKUTypes.SUBSCRIPTION_GROUP;
+}
+function $mk118395($env) {
+  return (a0) => $env[3].push(a0);
+}
+let getSkusHandler, getEntitlementsHandler;
+let env9410 = {};
+const getSubscriptionSkusViaListings = async function getSubscriptionSkusViaListings(c27503_0, c27503_1) {
+  let env30640;
+  const r9 = env30640 = {
+    $parent: env9410
+  };
+  let c27503_2 = r9;
+  env30640[0] = c27503_0;
+  env30640[1] = c27503_1;
+  env30640[2] = void 0;
+  env30640[3] = void 0;
+  const r17 = await Promise.all(c27503_1.filter((item) => item.type === SKUTypes.SUBSCRIPTION_GROUP).map((function() {
+    let c31691_0 = async (c32048_0) => await fetchAllSubscriptionListingsDataForApplication(env30640[0], c32048_0.id);
+    return function() {
+      return c31691_0.apply(this, arguments);
+    };
+  })()));
+  env30640[2] = r17;
+  env30640[3] = [];
+  env30640[2].forEach($mk116539(c27503_2));
+  return env30640[3];
+};
+getSkusHandler = async function getSkusHandler(c27504_0) {
+  let r198;
+  let c27504_1, c27504_2, value, c27504_4, c27504_5;
+  L22: {
+    let env30641;
+    const r9 = env9410;
+    c27504_5 = r9;
+    const r35 = env30641 = {
+      $parent: r9
+    };
+    c27504_4 = r35;
+    env30641[0] = void 0;
+    env30641[0] = c27504_0.socket;
+    env30641[1] = void 0;
+    env30641[2] = void 0;
+    env30641[3] = void 0;
+    env30641[4] = void 0;
+    await void 0;
+    validateTransportType(env30641[0].transport);
+    env30641[1] = env30641[0].application.id;
+    if (env30641[1] == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_COMMAND
+      }, "No application.");
+    }
+    if (isTestModeForApplication(env30641[1])) {
+      env30641[2] = await fetchTestSKUsForApplication(env30641[1], false);
+      env30641[3] = await (0, getSubscriptionSkusViaListings)(env30641[1], env30641[2]);
+      c27504_1 = 0;
+      const r197 = env30641[2].filter((item) => item.price != null);
+      r198 = [];
+      const r201 = HermesBuiltin.arraySpread(r198, r197, c27504_1);
+      c27504_1 = r201;
+      c27504_1 = HermesBuiltin.arraySpread(r198, env30641[3], r201);
+      break L22;
+    }
+    env30641[4] = await fetchAllStoreListingsForApplication(env30641[1]);
+    c27504_2 = 0;
+    const r126 = env30641[4].filter($mk116541(env9410)).map((item) => item.sku).filter((item) => item.price != null);
+    value = [];
+    c27504_2 = HermesBuiltin.arraySpread(value, r126, c27504_2);
+    c27504_2 = HermesBuiltin.arraySpread(value, await (0, getSubscriptionSkusViaListings)(env30641[1], env30641[4].map((item) => item.sku)), c27504_2);
+    return value;
+  }
+  return r198;
+};
+getEntitlementsHandler = function getEntitlementsHandler({ socket }) {
+  validateTransportType(socket.transport);
+  const id = socket.application.id;
+  if (id == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_COMMAND
+    }, "No application.");
+  }
+  return fetchUserEntitlementsForApplication(id);
+};
+const { RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const r33 = {};
+const GET_SKUS = RPCCommands.GET_SKUS;
+const r35 = {};
+r35[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE];
+r35.handler = getSkusHandler;
+r33[GET_SKUS] = r35;
+const GET_ENTITLEMENTS = RPCCommands.GET_ENTITLEMENTS;
+const r37 = {};
+r37[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE];
+r37.handler = getEntitlementsHandler;
+r33[GET_ENTITLEMENTS] = r37;
+const GET_SKUS_EMBEDDED = RPCCommands.GET_SKUS_EMBEDDED;
+const r41 = {};
+r41[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE];
+r41.handler = async (c20529_0) => {
+  const value2 = {};
+  value2.skus = await getSkusHandler(c20529_0);
+  return value2;
+};
+r33[GET_SKUS_EMBEDDED] = r41;
+const GET_ENTITLEMENTS_EMBEDDED = RPCCommands.GET_ENTITLEMENTS_EMBEDDED;
+const r46 = {};
+r46[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE];
+r46.handler = async (c20530_0) => {
+  const value3 = {};
+  value3.entitlements = await getEntitlementsHandler(c20530_0);
+  return value3;
+};
+r33[GET_ENTITLEMENTS_EMBEDDED] = r46;
+export default r33;

modules/rpc/server/commands/subscriptions.tsx

@@ -0,0 +1,118 @@
+// Metro module 13558 (f13559).
+import { RPCCommands, RPCErrors, AnalyticEvents } from "../../../../Constants";
+import RPCError from "../../RPCError";
+import validateScope from "../../helpers/validateScope";
+import AnalyticsUtils from "../../../../utils/AnalyticsUtils";
+import { getInitialSubscriptionPayload } from "../events/subscriptionHelpers";
+function $mk116546($env) {
+  return (a0) => {
+    setImmediate($mk118396($env));
+    a0({
+      evt: $env.$parent[2]
+    });
+  };
+}
+function $mk118396($env) {
+  return () => {
+    const r2 = $env;
+    const r1 = $env.$parent;
+    const r5 = r1[0];
+    const r12 = r1[1];
+    const r4 = r1[2];
+    r5.addSubscription(r12, r4, r1[3], r2[2]);
+    if (r2[3] != null) {
+      const r16 = r2[3];
+      r5.dispatchToSubscriptions(r4, $mk118909(r1), r16);
+    }
+  };
+}
+function $mk118909($env) {
+  return (a0) => a0.socket.id === $env[1].id;
+}
+let env9416 = {};
+const r19 = {};
+r19[RPCCommands.SUBSCRIBE] = {
+  handler: async (a0) => {
+    let promise;
+    let env20532 = {
+      $parent: env9416
+    };
+    env20532[0] = a0.server;
+    env20532[1] = a0.socket;
+    env20532[2] = a0.evt;
+    env20532[3] = a0.args;
+    let c27510_0, c27510_1;
+    L21: {
+      let env30645;
+      const r34 = env20532;
+      c27510_1 = r34;
+      const r13 = env30645 = {
+        $parent: r34
+      };
+      c27510_0 = r13;
+      env30645[0] = void 0;
+      env30645[1] = void 0;
+      env30645[2] = void 0;
+      env30645[3] = void 0;
+      const r11 = env20532[0];
+      const r35 = r11.events[env20532[2]];
+      env30645[0] = r35;
+      if (r35 == null) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_EVENT
+        }, `Invalid event: ${env20532[2]}`);
+      }
+      if (!validateScope(env20532[1].authorization.scopes, r35.scope)) {
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_PERMISSIONS
+        }, "Not authenticated or invalid scope");
+      }
+      AnalyticsUtils.track(AnalyticEvents.RPC_SUBSCRIPTION_REQUESTED, {
+        event: env20532[2],
+        scope: typeof r35.scope === "object" ? JSON.stringify(r35.scope) : r35.scope,
+        application_id: env20532[1].application.id,
+        socket_scope: env20532[1].authorization.scopes.toString()
+      });
+      if (r35.validation != null) {
+        env30645[1] = await r11.getJoi();
+        if (env30645[1].validate(env20532[3], env30645[0].validation(env30645[1]), {
+          convert: false
+        }).error == null) {
+          const r147 = c27510_0;
+          env30645[2] = env30645[0].handler({
+            args: env20532[3],
+            socket: env20532[1]
+          });
+          env30645[3] = getInitialSubscriptionPayload(env20532[1], env20532[2], env20532[3]);
+          promise = new Promise($mk116546(r147));
+          break L21;
+        }
+        throw new RPCError({
+          errorCode: RPCErrors.INVALID_PAYLOAD
+        }, "Invalid subscription parameters provided");
+      }
+      const r95 = c27510_0;
+      env30645[2] = env30645[0].handler({
+        args: env20532[3],
+        socket: env20532[1]
+      });
+      env30645[3] = getInitialSubscriptionPayload(env20532[1], env20532[2], env20532[3]);
+      return new Promise($mk116546(r95));
+    }
+    return promise;
+  }
+};
+r19[RPCCommands.UNSUBSCRIBE] = {
+  handler: ({ server, socket, evt, args }) => {
+    if (server.events[evt] == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_EVENT
+      }, `Invalid event: ${evt}`);
+    }
+    server.removeSubscription(socket, evt, args);
+    return {
+      evt
+    };
+  }
+};
+export default r19;

modules/rpc/server/commands/userSettings.tsx

@@ -0,0 +1,12 @@
+// Metro module 13562 (f13563).
+import LocaleStore from "../../../user_settings/LocaleStore";
+import { RPCCommands } from "../../../../Constants";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+const r17 = {};
+r17[RPCCommands.USER_SETTINGS_GET_LOCALE] = {
+  scope: OAuth2Scopes.IDENTIFY,
+  handler: () => ({
+    locale: LocaleStore.locale
+  })
+};
+export default r17;

modules/rpc/server/commands/users.tsx

@@ -0,0 +1,20 @@
+// Metro module 13561 (f13562).
+import UserStore from "../../../../stores/UserStore";
+import * as _Constants from "../../Constants";
+import { RPCCommands } from "../../../../Constants";
+import { createRPCCommand } from "../../../../_bundle/Module13535";
+import transformUser from "../../helpers/transformUser";
+const { RPC_EMBEDDED_APP_SCOPE, RPC_LOCAL_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const r25 = {};
+const GET_USER = RPCCommands.GET_USER;
+const GET_USER2 = RPCCommands.GET_USER;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [RPC_EMBEDDED_APP_SCOPE, RPC_LOCAL_SCOPE];
+r25[GET_USER] = createRPCCommand(GET_USER2, {
+  scope,
+  handler: (a0) => {
+    const user = UserStore.getUser(a0.args.id);
+    return user != null ? transformUser(user) : null;
+  }
+});
+export default r25;

modules/rpc/server/commands/voiceChannelChat.tsx

@@ -0,0 +1,26 @@
+// Metro module 13567 (f13568).
+import { RPC_LOCAL_SCOPE } from "../../Constants";
+import { RPCErrors, RPCCommands } from "../../../../Constants";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import { toggleVoiceChannelChat } from "../../../calls/toggleVoiceChannelChat";
+import RPCError from "../../RPCError";
+const r19 = {};
+r19[RPCCommands.TOGGLE_VOICE_CHANNEL_CHAT] = {
+  scope: RPC_LOCAL_SCOPE,
+  validation: (a0) => createRpcJoiSchemaObject(a0).keys({
+    open: a0.boolean()
+  }),
+  handler: (a0) => {
+    const r14 = toggleVoiceChannelChat(a0.args.open);
+    if (r14 == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, "Not connected to a guild voice channel");
+    }
+    return {
+      channel_id: r14.channelId,
+      chat_open: r14.chatOpen
+    };
+  }
+};
+export default r19;

modules/rpc/server/events/VoiceSettingsEventsFactory.tsx

@@ -0,0 +1,35 @@
+// Metro module 13579 (f13580).
+import { RPC_LOCAL_SCOPE, RPC_SCOPE_CONFIG } from "../../Constants";
+import { RPCEvents } from "../../../../Constants";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import Module12 from "../../../../_bundle/Module12";
+export default function createVoiceSettingsEventHandlers(c20545_0, c20545_1) {
+  const r14 = {};
+  const VOICE_SETTINGS_UPDATE = RPCEvents.VOICE_SETTINGS_UPDATE;
+  const scope = {};
+  scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ];
+  r14[VOICE_SETTINGS_UPDATE] = {
+    scope,
+    handler: () => ({ prevState, dispatch: dispatch2 }) => {
+      const r8 = c20545_0();
+      if (!Module12.isEqual(r8, prevState)) {
+        dispatch2(r8);
+      }
+      return r8;
+    }
+  };
+  r14[RPCEvents.VOICE_SETTINGS_UPDATE_2] = {
+    scope: RPC_LOCAL_SCOPE,
+    handler: ({ socket }) => ({ prevState, dispatch: dispatch2 }) => {
+      if (socket.application.id == null) {
+        return prevState;
+      }
+      const r14 = c20545_1(socket.application.id);
+      if (!Module12.isEqual(r14, prevState)) {
+        dispatch2(r14);
+      }
+      return r14;
+    }
+  };
+  return r14;
+};

modules/rpc/server/events/crossPlatformRPCEventHandlers.tsx

@@ -0,0 +1,430 @@
+// Metro module 13575 (f13576).
+import ApplicationStore from "../../../applications/ApplicationStore";
+import RunningGameStore_native from "../../../game_detection/RunningGameStore.native";
+import { getGuildIconURL } from "../../../../records/GuildRecord";
+import ApplicationStreamingStore from "../../../../stores/ApplicationStreamingStore";
+import ChannelStore from "../../../../stores/ChannelStore";
+import GuildMemberStore from "../../../../stores/GuildMemberStore";
+import GuildStore from "../../../../stores/GuildStore";
+import MediaEngineStore from "../../../../stores/MediaEngineStore";
+import RTCConnectionStore from "../../../../stores/RTCConnectionStore";
+import UserStore from "../../../../stores/UserStore";
+import VoiceStateStore from "../../../../stores/VoiceStateStore";
+import * as _Constants from "../../Constants";
+import { ApplicationFlags, RPCErrors, RPCEvents } from "../../../../Constants";
+import createRpcJoiSchemaObject from "../../helpers/createRpcJoiSchemaObject";
+import { hasMessageReadPermission, transformVoiceState, getVoiceConnectionState } from "../../RPCHelpers";
+import RPCError from "../../RPCError";
+import { userCannotSeeNSFWContent } from "../../../age_gate/AgeGateUtils";
+import { OAuth2Scopes } from "../../../../_bundle/Module8174";
+import Module12 from "../../../../_bundle/Module12";
+import { activityInstanceConnectedParticipantsUpdateEvent } from "../../helpers/activityInstanceConnectedParticipants";
+import { has, deserialize } from "../../../../_bundle/HighLow";
+import shallowEqual from "../../../../_bundle/shallowEqual";
+import transformUser from "../../helpers/transformUser";
+import transformGuildMember from "../../helpers/transformGuildMember";
+import transformApplication from "../../helpers/transformApplication";
+const messageEventsValidation = function messageEventsValidation(a0) {
+  return createRpcJoiSchemaObject(a0).required().keys({
+    channel_id: a0.string().required()
+  });
+};
+const messageEvents = function messageEvents(a0) {
+  const channel_id4 = a0.args.channel_id;
+  const socket = a0.socket;
+  const channel4 = ChannelStore.getChannel(channel_id4);
+  if (channel4 != null && hasMessageReadPermission(channel4, socket.application.id, socket.authorization.scopes)) {
+    if (userCannotSeeNSFWContent(channel4)) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, `Invalid nsfw channel id: ${channel4.id}`);
+    }
+    return void 0;
+  }
+  throw new RPCError({
+    errorCode: RPCErrors.INVALID_CHANNEL
+  }, `Invalid channel id: ${channel_id4}`);
+};
+const speakingEventsValidation = function speakingEventsValidation(a0) {
+  return createRpcJoiSchemaObject(a0).keys({
+    channel_id: a0.string().allow(null)
+  });
+};
+const speakingEvents = function speakingEvents(a0) {
+  const channel_id4 = a0.args.channel_id;
+  if (channel_id4 != null && ChannelStore.getChannel(channel_id4) == null) {
+    throw new RPCError({
+      errorCode: RPCErrors.INVALID_CHANNEL
+    }, `Invalid channel id: ${channel_id4}`);
+  }
+};
+const { RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE, RPC_SCOPE_CONFIG } = _Constants;
+const r54 = {};
+r54[RPCEvents.GUILD_STATUS] = {
+  scope: OAuth2Scopes.RPC,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    guild_id: a0.string().required()
+  }),
+  handler: (a0) => {
+    const guild_id = a0.args.guild_id;
+    if (GuildStore.getGuild(guild_id) == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_GUILD
+      }, `Invalid guild id: ${guild_id}`);
+    }
+    return ({ prevState, dispatch: dispatch4 }) => {
+      const guild = GuildStore.getGuild(guild_id);
+      if (guild != null) {
+        let icon_url = getGuildIconURL(guild, 128);
+        if (icon_url == null) {
+          icon_url = null;
+        }
+        const r18 = {
+          guild: {
+            id: guild.id,
+            name: guild.name,
+            icon_url
+          },
+          online: 0
+        };
+        if (!Module12.isEqual(prevState, r18)) {
+          dispatch4(r18);
+        }
+        return r18;
+      }
+    };
+  }
+};
+const VOICE_STATE_CREATE = RPCEvents.VOICE_STATE_CREATE;
+const scope = {};
+scope[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ];
+r54[VOICE_STATE_CREATE] = {
+  scope,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    channel_id: a0.string().required()
+  }),
+  handler: (a0) => {
+    const channel_id = a0.args.channel_id;
+    if (ChannelStore.getChannel(channel_id) == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, `Invalid channel id: ${channel_id}`);
+    }
+    return ({ prevState, dispatch }) => {
+      let guildId;
+      guildId = void 0;
+      const channel = ChannelStore.getChannel(channel_id);
+      if (channel != null) {
+        guildId = channel.getGuildId();
+        const r21 = Object.values(VoiceStateStore.getVoiceStatesForChannel(channel.id));
+        if (prevState) {
+          Module12.differenceBy(r21, prevState, (a0) => a0.userId).forEach((item) => dispatch(transformVoiceState(guildId, channel.id, item)));
+        }
+        return r21;
+      }
+    };
+  }
+};
+const VOICE_STATE_DELETE = RPCEvents.VOICE_STATE_DELETE;
+const scope2 = {};
+scope2[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ];
+r54[VOICE_STATE_DELETE] = {
+  scope: scope2,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    channel_id: a0.string().required()
+  }),
+  handler: (a0) => {
+    const channel_id2 = a0.args.channel_id;
+    if (ChannelStore.getChannel(channel_id2) == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, `Invalid channel id: ${channel_id2}`);
+    }
+    return ({ prevState, dispatch: dispatch2 }) => {
+      let guildId2;
+      guildId2 = void 0;
+      const channel2 = ChannelStore.getChannel(channel_id2);
+      if (channel2 != null) {
+        guildId2 = channel2.getGuildId();
+        const r21 = Object.values(VoiceStateStore.getVoiceStatesForChannel(channel2.id));
+        Module12.differenceBy(prevState, r21, (a0) => a0.userId).forEach((item) => dispatch2(transformVoiceState(guildId2, channel2.id, item)));
+        return r21;
+      }
+    };
+  }
+};
+const VOICE_STATE_UPDATE = RPCEvents.VOICE_STATE_UPDATE;
+const scope3 = {};
+scope3[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ];
+r54[VOICE_STATE_UPDATE] = {
+  scope: scope3,
+  validation: (a0) => createRpcJoiSchemaObject(a0).required().keys({
+    channel_id: a0.string().required()
+  }),
+  handler: (a0) => {
+    const channel_id3 = a0.args.channel_id;
+    if (ChannelStore.getChannel(channel_id3) == null) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_CHANNEL
+      }, `Invalid channel id: ${channel_id3}`);
+    }
+    return ({ prevState, dispatch: dispatch3 }) => {
+      let guildId3;
+      guildId3 = void 0;
+      const channel3 = ChannelStore.getChannel(channel_id3);
+      if (channel3 != null) {
+        guildId3 = channel3.getGuildId();
+        const r24 = Object.values(VoiceStateStore.getVoiceStatesForChannel(channel3.id)).map((item) => transformVoiceState(guildId3, channel3.id, item));
+        Module12.differenceWith(r24, prevState, Module12.isEqual).forEach((item) => dispatch3(item));
+        return r24;
+      }
+    };
+  }
+};
+const VOICE_CONNECTION_STATUS = RPCEvents.VOICE_CONNECTION_STATUS;
+const scope4 = {};
+scope4[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ];
+r54[VOICE_CONNECTION_STATUS] = {
+  scope: scope4,
+  handler: () => ({ prevState, dispatch: dispatch4 }) => {
+    const r14 = {
+      state: getVoiceConnectionState(RTCConnectionStore.getState()),
+      hostname: RTCConnectionStore.getHostname(),
+      pings: RTCConnectionStore.getPings(),
+      average_ping: RTCConnectionStore.getAveragePing(),
+      last_ping: RTCConnectionStore.getLastPing()
+    };
+    if (!Module12.isEqual(r14, prevState)) {
+      dispatch4(r14);
+    }
+    return r14;
+  }
+};
+r54[RPCEvents.MESSAGE_CREATE] = {
+  scope: OAuth2Scopes.RPC,
+  validation: messageEventsValidation,
+  handler: messageEvents
+};
+r54[RPCEvents.MESSAGE_UPDATE] = {
+  scope: OAuth2Scopes.RPC,
+  validation: messageEventsValidation,
+  handler: messageEvents
+};
+r54[RPCEvents.MESSAGE_DELETE] = {
+  scope: OAuth2Scopes.RPC,
+  validation: messageEventsValidation,
+  handler: messageEvents
+};
+const SPEAKING_START = RPCEvents.SPEAKING_START;
+const scope5 = {};
+scope5[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ, RPC_LOCAL_SCOPE];
+r54[SPEAKING_START] = {
+  scope: scope5,
+  validation: speakingEventsValidation,
+  handler: speakingEvents
+};
+const SPEAKING_STOP = RPCEvents.SPEAKING_STOP;
+const scope6 = {};
+scope6[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_VOICE_READ, RPC_LOCAL_SCOPE];
+r54[SPEAKING_STOP] = {
+  scope: scope6,
+  validation: speakingEventsValidation,
+  handler: speakingEvents
+};
+r54[RPCEvents.GUILD_CREATE] = {
+  scope: OAuth2Scopes.RPC,
+  handler: () => {}
+};
+r54[RPCEvents.CHANNEL_CREATE] = {
+  scope: OAuth2Scopes.RPC,
+  handler: () => {}
+};
+const GAME_JOIN = RPCEvents.GAME_JOIN;
+const scope7 = {};
+scope7[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE];
+r54[GAME_JOIN] = {
+  scope: scope7,
+  handler: () => {}
+};
+const GAME_SPECTATE = RPCEvents.GAME_SPECTATE;
+const scope8 = {};
+scope8[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE];
+r54[GAME_SPECTATE] = {
+  scope: scope8,
+  handler: () => {}
+};
+const ACTIVITY_JOIN = RPCEvents.ACTIVITY_JOIN;
+const scope9 = {};
+scope9[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE];
+r54[ACTIVITY_JOIN] = {
+  scope: scope9,
+  handler: () => {}
+};
+const ACTIVITY_JOIN_REQUEST = RPCEvents.ACTIVITY_JOIN_REQUEST;
+const scope10 = {};
+scope10[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE];
+r54[ACTIVITY_JOIN_REQUEST] = {
+  scope: scope10,
+  handler: () => {}
+};
+const ACTIVITY_SPECTATE = RPCEvents.ACTIVITY_SPECTATE;
+const scope11 = {};
+scope11[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_AUTHENTICATED_SCOPE, RPC_LOCAL_SCOPE];
+r54[ACTIVITY_SPECTATE] = {
+  scope: scope11,
+  handler: () => {}
+};
+const ACTIVITY_INVITE = RPCEvents.ACTIVITY_INVITE;
+const scope12 = {};
+scope12[RPC_SCOPE_CONFIG.ANY] = [OAuth2Scopes.RPC, RPC_LOCAL_SCOPE];
+r54[ACTIVITY_INVITE] = {
+  scope: scope12,
+  handler: () => {}
+};
+r54[RPCEvents.ACTIVITY_PIP_MODE_UPDATE] = {
+  scope: void 0,
+  handler: () => {}
+};
+r54[RPCEvents.ACTIVITY_LAYOUT_MODE_UPDATE] = {
+  scope: void 0,
+  handler: () => {}
+};
+r54[RPCEvents.FRAME_LAYOUT_MODE_UPDATE] = {
+  scope: void 0,
+  handler: () => {}
+};
+r54[RPCEvents.ACTIVITY_INSTANCE_PARTICIPANTS_UPDATE] = activityInstanceConnectedParticipantsUpdateEvent;
+const THERMAL_STATE_UPDATE = RPCEvents.THERMAL_STATE_UPDATE;
+const scope13 = {};
+scope13[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE];
+r54[THERMAL_STATE_UPDATE] = {
+  scope: scope13,
+  handler: () => {}
+};
+const ORIENTATION_UPDATE = RPCEvents.ORIENTATION_UPDATE;
+const scope14 = {};
+scope14[RPC_SCOPE_CONFIG.ANY] = [RPC_AUTHENTICATED_SCOPE];
+r54[ORIENTATION_UPDATE] = {
+  scope: scope14,
+  handler: () => {}
+};
+r54[RPCEvents.VOICE_CHANNEL_SELECT] = {
+  scope: OAuth2Scopes.RPC,
+  handler: () => {}
+};
+const NOTIFICATION_CREATE = RPCEvents.NOTIFICATION_CREATE;
+const scope15 = {};
+scope15[RPC_SCOPE_CONFIG.ALL] = [OAuth2Scopes.RPC, OAuth2Scopes.RPC_NOTIFICATIONS_READ];
+r54[NOTIFICATION_CREATE] = {
+  scope: scope15,
+  handler: () => {}
+};
+r54[RPCEvents.RELATIONSHIP_UPDATE] = {
+  scope: OAuth2Scopes.RELATIONSHIPS_READ,
+  handler: (a0) => {
+    let flags = a0.socket.application.flags;
+    if (flags == null) {
+      flags = 0;
+    }
+    if (has(deserialize(flags), deserialize(ApplicationFlags.DISABLE_RELATIONSHIPS_ACCESS))) {
+      throw new RPCError({
+        errorCode: RPCErrors.INVALID_PERMISSIONS
+      }, "Missing Permissions");
+    }
+  }
+};
+const CURRENT_USER_UPDATE = RPCEvents.CURRENT_USER_UPDATE;
+const scope16 = {};
+scope16[RPC_SCOPE_CONFIG.ANY] = [RPC_LOCAL_SCOPE, OAuth2Scopes.IDENTIFY];
+r54[CURRENT_USER_UPDATE] = {
+  scope: scope16,
+  handler: () => ({ prevState, dispatch: dispatch4 }) => {
+    const r10 = {
+      currentUser: UserStore.getCurrentUser()
+    };
+    if (!(r10.currentUser == null || prevState != null && shallowEqual(r10, prevState))) {
+      dispatch4(transformUser(r10.currentUser));
+    }
+    return r10;
+  }
+};
+const CURRENT_GUILD_MEMBER_UPDATE = RPCEvents.CURRENT_GUILD_MEMBER_UPDATE;
+const scope17 = {};
+scope17[RPC_SCOPE_CONFIG.ALL] = [OAuth2Scopes.IDENTIFY, OAuth2Scopes.GUILDS_MEMBERS_READ];
+r54[CURRENT_GUILD_MEMBER_UPDATE] = {
+  scope: scope17,
+  handler: (a0) => {
+    const guild_id2 = a0.args.guild_id;
+    return ({ prevState, dispatch: dispatch4 }) => {
+      const r11 = {
+        currentGuildMember: GuildMemberStore.getSelfMember(guild_id2)
+      };
+      if (!(r11.currentGuildMember == null || prevState != null && shallowEqual(r11, prevState))) {
+        dispatch4(transformGuildMember(r11.currentGuildMember));
+      }
+      return r11;
+    };
+  }
+};
+const ENTITLEMENT_CREATE = RPCEvents.ENTITLEMENT_CREATE;
+const scope18 = {};
+scope18[RPC_SCOPE_CONFIG.ANY] = [RPC_LOCAL_SCOPE, RPC_AUTHENTICATED_SCOPE];
+r54[ENTITLEMENT_CREATE] = {
+  scope: scope18,
+  handler: () => {}
+};
+const ENTITLEMENT_DELETE = RPCEvents.ENTITLEMENT_DELETE;
+const scope19 = {};
+scope19[RPC_SCOPE_CONFIG.ANY] = [RPC_LOCAL_SCOPE, RPC_AUTHENTICATED_SCOPE];
+r54[ENTITLEMENT_DELETE] = {
+  scope: scope19,
+  handler: () => {}
+};
+const SCREENSHARE_STATE_UPDATE = RPCEvents.SCREENSHARE_STATE_UPDATE;
+const scope20 = {};
+scope20[RPC_SCOPE_CONFIG.ALL] = [RPC_LOCAL_SCOPE, OAuth2Scopes.RPC_SCREENSHARE_READ];
+r54[SCREENSHARE_STATE_UPDATE] = {
+  scope: scope20,
+  handler: () => ({ prevState, dispatch: dispatch4 }) => {
+    const streamerActiveStreamMetadata = ApplicationStreamingStore.getStreamerActiveStreamMetadata();
+    const r15 = streamerActiveStreamMetadata?.pid != null ? RunningGameStore_native.getGameForPID(streamerActiveStreamMetadata.pid) : null;
+    const r19 = r15?.id != null ? ApplicationStore.getApplication(r15.id) : null;
+    const r24 = r19 != null ? transformApplication(r19) : null;
+    const sourceName = streamerActiveStreamMetadata?.sourceName;
+    let pid = streamerActiveStreamMetadata?.pid;
+    if (pid == null) {
+      pid = null;
+    }
+    const r32 = {
+      active: streamerActiveStreamMetadata != null,
+      pid,
+      application: r24 != null ? {
+        name: sourceName
+      } : null
+    };
+    if (!Module12.isEqual(r32, prevState)) {
+      dispatch4(r32);
+    }
+    return r32;
+  }
+};
+const VIDEO_STATE_UPDATE = RPCEvents.VIDEO_STATE_UPDATE;
+const scope21 = {};
+scope21[RPC_SCOPE_CONFIG.ALL] = [RPC_LOCAL_SCOPE, OAuth2Scopes.RPC_VIDEO_READ];
+r54[VIDEO_STATE_UPDATE] = {
+  scope: scope21,
+  handler: () => ({ prevState, dispatch: dispatch4 }) => {
+    const r8 = {
+      active: MediaEngineStore.isVideoEnabled()
+    };
+    if (!Module12.isEqual(r8, prevState)) {
+      dispatch4(r8);
+    }
+    return r8;
+  }
+};
+r54[RPCEvents.AUTHORIZE_REQUEST] = {
+  scope: void 0,
+  handler: () => {}
+};
+export default r54;

modules/rpc/server/events/subscriptionHelpers.tsx

@@ -0,0 +1,78 @@
+// Metro module 13560 (f13561).
+import EmbeddedActivitiesStore from "../../../activities/EmbeddedActivitiesStore";
+import FramesStore from "../../../frames/FramesStore";
+import QuestStore from "../../../quests/QuestStore";
+import { RPCEvents } from "../../../../Constants";
+import { ActivityLayoutMode, ActivityScreenOrientation } from "../../../activities/Constants";
+import { getThermalState, ThermalStates } from "../../../device/useThermalState";
+import { getIsScreenLandscape } from "../../../screen/useIsScreenLandscape.native";
+import { activityInstanceConnectedParticipants } from "../../helpers/activityInstanceConnectedParticipants";
+import { getActivityApplicationId } from "../../../quests/utils/QuestTaskUtils";
+export function getInitialSubscriptionPayload(a0, a1, a2) {
+  if (RPCEvents.ACTIVITY_PIP_MODE_UPDATE === a1) {
+    const id3 = a0.application?.id;
+    const r100 = id3 != null ? EmbeddedActivitiesStore.getLayoutModeForApp(id3) : null;
+    return r100 != null ? {
+      is_pip_mode: r100 !== ActivityLayoutMode.FOCUSED
+    } : null;
+  }
+  if (RPCEvents.ACTIVITY_LAYOUT_MODE_UPDATE === a1) {
+    const id2 = a0.application?.id;
+    const layout_mode2 = id2 != null ? EmbeddedActivitiesStore.getLayoutModeForApp(id2) : null;
+    return layout_mode2 != null ? {
+      layout_mode: layout_mode2
+    } : null;
+  }
+  if (RPCEvents.FRAME_LAYOUT_MODE_UPDATE === a1) {
+    const layout_mode = a0.application?.id != null ? FramesStore.getConnectedFrame()?.layoutMode : null;
+    return layout_mode != null ? {
+      layout_mode
+    } : null;
+  }
+  if (RPCEvents.THERMAL_STATE_UPDATE === a1) {
+    const thermalState = getThermalState();
+    return thermalState !== ThermalStates.UNHANDLED ? {
+      thermal_state: thermalState
+    } : null;
+  }
+  if (RPCEvents.ORIENTATION_UPDATE === a1) {
+    return {
+      screen_orientation: getIsScreenLandscape() ? ActivityScreenOrientation.LANDSCAPE : ActivityScreenOrientation.PORTRAIT
+    };
+  }
+  if (RPCEvents.ACTIVITY_INSTANCE_PARTICIPANTS_UPDATE === a1) {
+    return activityInstanceConnectedParticipants();
+  }
+  if (RPCEvents.QUEST_ENROLLMENT_STATUS_UPDATE === a1) {
+    const quest_id = a2.quest_id;
+    if (quest_id) {
+      const quest = QuestStore.getQuest(quest_id);
+      const activityApplicationId = getActivityApplicationId(quest);
+      const r1 = quest == null;
+      let r28 = null;
+      if (!r1) {
+        const r29 = activityApplicationId == null;
+        r28 = null;
+        if (!r29) {
+          const id = a0.application?.id;
+          r28 = null;
+          if (activityApplicationId === id) {
+            const enrolledAt = quest.userStatus?.enrolledAt;
+            let enrolled_at = quest.userStatus?.enrolledAt;
+            if (enrolled_at == null) {
+              enrolled_at = null;
+            }
+            r28 = {
+              quest_id,
+              is_enrolled: enrolledAt != null,
+              enrolled_at
+            };
+          }
+        }
+      }
+      return r28;
+    }
+    return null;
+  }
+  return null;
+}

modules/rpc/transports/BaseSocket.tsx

@@ -0,0 +1,41 @@
+// Metro module 10636 (f10637).
+import { RPCCloseCodes, RPC_VERSION } from "../../../Constants";
+import Module12 from "../../../_bundle/Module12";
+import RPCError from "../RPCError";
+class BaseSocket {
+  constructor(a0, a1, a2) {
+    const r16 = {
+      __proto__: new.target.prototype,
+      id: Module12.uniqueId(),
+      authorization: null,
+      application: null,
+      abortController: null
+    };
+    r16.authorization = {
+      authing: false,
+      scopes: [],
+      accessToken: null,
+      expires: new Date(0)
+    };
+    r16.application = {
+      id: null,
+      name: null,
+      icon: null
+    };
+    r16.abortController = new AbortController();
+    r16.transport = a0;
+    r16.version = a1;
+    r16.encoding = a2;
+    r16.checkRpcVersion(a1);
+    return r16;
+  }
+  checkRpcVersion(a0) {
+    if (a0 != null && !(a0 > RPC_VERSION) && !(a0 < 1)) {
+      return void 0;
+    }
+    throw new RPCError({
+      closeCode: RPCCloseCodes.INVALID_VERSION
+    }, `Invalid Version: ${a0}`);
+  }
+}
+export default BaseSocket;

modules/rpc/transports/PostMessageProxySocket.tsx

@@ -0,0 +1,46 @@
+// Metro module 10635 (f10636).
+import { TransportTypes } from "../Constants";
+import { RPCCloseCodes } from "../../../Constants";
+import BaseSocket from "./BaseSocket";
+import RPCError from "../RPCError";
+import RPCOpcodes from "../RPCOpcodes";
+class WindowProxySocket extends BaseSocket {
+  constructor({ origin, postMessageToRPCClient, frameId, version, encoding, logger, postClose, onSendingToRPCClient }) {
+    const POST_MESSAGE = TransportTypes.POST_MESSAGE;
+    super(POST_MESSAGE, version, encoding);
+    if (["etf", "json"].indexOf(encoding) === -1) {
+      throw new RPCError({
+        closeCode: RPCCloseCodes.INVALID_ENCODING
+      }, `Invalid Encoding: ${encoding}`);
+    }
+    if (encoding === "etf") {
+      throw new RPCError({
+        closeCode: RPCCloseCodes.INVALID_ENCODING
+      }, "Erlpack cannot be used on this client");
+    }
+    this.origin = origin;
+    this.postMessageToRPCClient = postMessageToRPCClient;
+    this.frameId = frameId;
+    this.logger = logger;
+    this.postClose = postClose;
+    this.onSendingToRPCClient = onSendingToRPCClient;
+    this.closed = false;
+  }
+  send(a0) {
+    const onSendingToRPCClient = this.onSendingToRPCClient;
+    if (onSendingToRPCClient != null) {
+      onSendingToRPCClient.call(this, a0, this.id);
+    }
+    this.postMessageToRPCClient([RPCOpcodes.FRAME, a0], this.origin);
+  }
+  close(a0, a1) {
+    if (!this.closed) {
+      this.postClose(this.origin, {
+        code: a0,
+        message: a1
+      }, this.postMessageToRPCClient);
+    }
+    this.closed = true;
+  }
+}
+export default WindowProxySocket;

modules/rpc/transports/PostMessageTransport.tsx

@@ -0,0 +1,345 @@
+// Metro module 10624 (f10625).
+import EmbeddedActivitiesStore from "../../activities/EmbeddedActivitiesStore";
+import { RPC_EMBEDDED_APP_SCOPE } from "../Constants";
+import { AnalyticEvents, ComponentActions, RPCCloseCodes, RPCErrors } from "../../../Constants";
+import Durations from "../../../utils/Durations";
+import RPCOpcodes from "../RPCOpcodes";
+import { EventEmitter } from "../../../_bundle/EventEmitter_652";
+import { ComponentDispatch } from "../../../utils/ComponentDispatchUtils";
+import AnalyticsUtils from "../../../utils/AnalyticsUtils";
+import { getEmbeddedActivityLocationChannelId, getEmbeddedActivityLocationGuildId } from "../../activities/utils/embeddedActivityLocationUtils";
+import RPCError from "../RPCError";
+import createRpcJoiSchemaObject from "../helpers/createRpcJoiSchemaObject";
+const timeout_ms = 10 * Durations.Millis.SECOND;
+let c7129_12 = new Map();
+let c7129_13 = new Set();
+const postClose = (a0, a1, a2) => {
+  a2([RPCOpcodes.CLOSE, a1], a0);
+};
+class PostMessageTransport extends EventEmitter {
+  constructor(a0, a1, a2, a3) {
+    let c18157_0, c18157_1;
+    let c18158_0, c18158_1;
+    super();
+    const _this = this;
+    this.disconnectSocket = function disconnectSocket(a0, a1) {
+      let r5 = arguments[2];
+      if (r5 === void 0) {
+        r5 = false;
+      }
+      _this.emit("disconnect", a0, r5 ? void 0 : a1);
+      const close = a0.close;
+      const code = a1.code;
+      let message = a1.message;
+      if (message == null) {
+        message = "Unknown";
+      }
+      close.call(a0, code, message);
+      let r27 = Array.from(c7129_12.entries()).find((item) => {
+        const [, r13] = item;
+        return r13 === a0;
+      });
+      if (r27 == null) {
+        r27 = [null, null];
+      }
+      const [r30] = r27;
+      if (r30 != null) {
+        c7129_12.delete(r30);
+      }
+    };
+    this.handleIFrameMount = (a0) => {
+      c7129_13.add(a0.id);
+      _this.handshakeFailureTimeoutId = setTimeout(() => {
+        Array.from(EmbeddedActivitiesStore.getSelfEmbeddedActivities().entries()).forEach((item) => {
+          const [application_id, r8] = item;
+          AnalyticsUtils.track(AnalyticEvents.ACTIVITY_HANDSHAKE_TIMED_OUT, {
+            application_id,
+            channel_id: getEmbeddedActivityLocationChannelId(r8.location),
+            guild_id: getEmbeddedActivityLocationGuildId(r8.location),
+            timeout_ms
+          });
+        });
+      }, timeout_ms);
+    };
+    this.handleIFrameUnmount = ({ id }) => {
+      c7129_13.delete(id);
+      let r21 = Array.from(c7129_12.entries()).find((item) => {
+        const [, r13] = item;
+        return r13.frameId === id;
+      });
+      if (r21 == null) {
+        r21 = [null, null];
+      }
+      const [r24, r9] = r21;
+      if (r9 != null && r24 != null) {
+        _this.disconnectSocket(r9, {
+          code: RPCCloseCodes.CLOSE_NORMAL,
+          message: "iFrame gone"
+        }, true);
+        c7129_12.delete(r24);
+      }
+    };
+    this.handleMessage = (a0, a1, a2) => {
+      const r5 = c7129_12.get(a1);
+      try {
+        _this.routeEvent(r5, a1, a0, a2);
+      } catch (r17) {
+        if (r17 instanceof RPCError && r17.errorCode === RPCErrors.INVALID_PAYLOAD) {
+          throw r17;
+        }
+        if (r5 != null) {
+          _this.disconnectSocket(r5, {
+            code: r17.code,
+            message: r17.message
+          }, true);
+        } else {
+          postClose(a1, {
+            code: r17.code,
+            message: r17.message
+          }, a2);
+        }
+      }
+    };
+    this.handleFrame = (a0, a1, a2) => {
+      let r14;
+      if (a0 !== a1.origin) {
+        throw new RPCError({
+          closeCode: RPCCloseCodes.INVALID_ORIGIN
+        }, "Origin has changed");
+      }
+      try {
+        r14 = typeof a2 === "string" ? JSON.parse(a2) : a2;
+      } catch ($e) {
+        throw new RPCError({
+          closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+        }, "Payload not recognized encoding");
+      }
+      const onFrameHandled = _this.onFrameHandled;
+      if (onFrameHandled != null) {
+        onFrameHandled.call(_this, r14, _this.logger, a1);
+      }
+      _this.emit("request", a1, r14);
+    };
+    c18157_0 = void 0;
+    c18157_1 = this;
+    c18157_0 = async (c30245_0, c30245_1, c30245_2) => {
+      let encoding, c30245_6;
+      let c30245_7 = 0;
+      let c31537_0, c31537_1, c31537_2, c31537_3, c31537_4, c31537_5, c31537_6, c31537_7, c31537_8, c31537_9;
+      try {
+        c31537_0 = c30245_0;
+        c31537_1 = c30245_1;
+        c31537_2 = c30245_2;
+        c31537_3 = void 0;
+        c31537_4 = void 0;
+        c31537_5 = void 0;
+        c31537_6 = void 0;
+        if (c18157_1.handshakeFailureTimeoutId != null) {
+          clearTimeout(c18157_1.handshakeFailureTimeoutId);
+        }
+        c31537_3 = (await import("../../../_bundle/Module10628")).default;
+        c30245_7 = 1;
+        c31537_3.assert(c31537_1, createRpcJoiSchemaObject(c31537_3).required().keys({
+          v: c31537_3.number().min(1).max(1).required(),
+          encoding: c31537_3.string().equal("json").optional(),
+          client_id: c31537_3.string().required(),
+          frame_id: c31537_3.string().required(),
+          sdk_version: c31537_3.string().optional()
+        }));
+        c30245_7 = 0;
+        c31537_5 = c31537_1;
+        c31537_6 = c31537_5.frame_id;
+        if (!c7129_13.has(c31537_6)) {
+          c18157_1.logger.error(`Unrecognized frame ID ${c31537_6}`);
+          throw new RPCError({
+            closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+          }, `Unrecognized frame ID ${c31537_6}`);
+        }
+        if (c31537_5.sdk_version != null) {
+          AnalyticsUtils.track(AnalyticEvents.ACTIVITY_HANDSHAKE, {
+            application_id: c31537_5.client_id,
+            sdk_version: c31537_5.sdk_version
+          });
+        }
+        c30245_7 = 2;
+        const r181 = {
+          origin: c31537_0,
+          postMessageToRPCClient: c31537_2,
+          frameId: c31537_6,
+          version: Number(c31537_5.v),
+          logger: c18157_1.logger,
+          postClose,
+          encoding: null
+        };
+        const encoding2 = c31537_5.encoding;
+        encoding = encoding2;
+        if (encoding2 == null) {
+          encoding = "json";
+        }
+        r181.encoding = encoding;
+        c31537_4 = c18157_1.createPostMessageProxySocket(r181);
+        c30245_7 = 0;
+        c18157_1.logger.info(`Socket Opened: ${c31537_4.id}`);
+        c30245_7 = 3;
+        await c18157_1.validateSocketClient(c31537_4, c31537_0, c31537_5.client_id);
+        if (!c7129_13.has(c31537_6)) {
+          c18157_1.logger.error(`Frame ID ${c31537_6} no longer exists`);
+          throw new RPCError({
+            closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+          }, `Unrecognized frame ID ${c31537_6}`);
+        }
+        c7129_12.set(c31537_0, c31537_4);
+        c7129_13.delete(c31537_6);
+        c31537_4.authorization.scopes.push(RPC_EMBEDDED_APP_SCOPE);
+        c18157_1.emit("connect", c31537_4);
+        c18157_1.logger.info(`Socket Validated: ${c31537_4.id}`);
+        c30245_7 = 0;
+      } catch ($e) {
+        const r46 = $e;
+        let r7 = r46;
+        c30245_6 = r46;
+        let r47 = c30245_7;
+        if (r47 !== 0) {
+          while (true) {
+            if (r47 === 1) {
+              try {
+                const r367 = c30245_6;
+                c30245_7 = 0;
+                c31537_7 = r367;
+                throw new RPCError({
+                  closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+                }, c31537_7.message);
+              } catch (r364) {
+                r7 = r364;
+                c30245_6 = r364;
+                r47 = c30245_7;
+                if (r47 === 0) {
+                  break;
+                }
+              }
+            } else if (r47 === 2) {
+              try {
+                const r351 = c30245_6;
+                c30245_7 = 0;
+                c31537_8 = r351;
+                c18157_1.logger.error(`Error opening window socket ${c31537_8}`);
+                throw c31537_8;
+              } catch (r348) {
+                r7 = r348;
+                c30245_6 = r348;
+                r47 = c30245_7;
+                if (r47 === 0) {
+                  break;
+                }
+              }
+            } else {
+              try {
+                const r332 = c30245_6;
+                c30245_7 = 0;
+                c31537_9 = r332;
+                c18157_1.logger.info(`Socket Closed: ${c31537_4.id}, ${c31537_9.message}`);
+                throw c31537_9;
+              } catch (r329) {
+                r7 = r329;
+                c30245_6 = r329;
+                r47 = c30245_7;
+                if (r47 === 0) {
+                  break;
+                }
+              }
+            }
+          }
+        }
+        throw r7;
+      }
+    };
+    this.handleHandshake = function() {
+      return c18157_0.apply(this, arguments);
+    };
+    c18158_0 = void 0;
+    c18158_1 = this;
+    c18158_0 = async (c30246_0, c30246_1) => {
+      let c30246_4;
+      let c30246_5 = 0;
+      let c31538_0, c31538_1, c31538_2, c31538_3;
+      try {
+        c31538_0 = c30246_0;
+        c31538_1 = c30246_1;
+        c31538_2 = void 0;
+        c31538_2 = (await import("../../../_bundle/Module10628")).default;
+        c30246_5 = 1;
+        c31538_2.assert(c31538_1, createRpcJoiSchemaObject(c31538_2).required().keys({
+          code: c31538_2.number().valid(Object.values(RPCCloseCodes)).required(),
+          message: c31538_2.string().optional()
+        }));
+        c30246_5 = 0;
+        c18158_1.disconnectSocket(c31538_0, c31538_1);
+      } catch ($e) {
+        const r34 = $e;
+        let r7 = r34;
+        c30246_4 = r34;
+        if (c30246_5 !== 0) {
+          while (true) {
+            try {
+              const r105 = c30246_4;
+              c30246_5 = 0;
+              c31538_3 = r105;
+              throw new RPCError({
+                closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+              }, c31538_3.message);
+            } catch (r101) {
+              r7 = r101;
+              c30246_4 = r101;
+              if (c30246_5 === 0) {
+                break;
+              }
+            }
+          }
+        }
+        throw r7;
+      }
+    };
+    this.handleClose = function() {
+      return c18158_0.apply(this, arguments);
+    };
+    ComponentDispatch.subscribe(ComponentActions.IFRAME_MOUNT, this.handleIFrameMount);
+    ComponentDispatch.subscribe(ComponentActions.IFRAME_UNMOUNT, this.handleIFrameUnmount);
+    this.validateSocketClient = a0;
+    this.logger = a1;
+    this.createPostMessageProxySocket = a2;
+    this.onFrameHandled = a3;
+  }
+  routeEvent(a0, a1, a2, a3) {
+    if (Array.isArray(a2)) {
+      const [r11, r8] = a2;
+      if (RPCOpcodes.HANDSHAKE === r11) {
+        if (a0 != null) {
+          throw new RPCError({
+            closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+          }, "Already connected");
+        }
+        return this.handleHandshake(a1, r8, a3);
+      }
+      if (RPCOpcodes.FRAME === r11) {
+        if (a0 == null) {
+          throw new RPCError({
+            closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+          }, "Not connected");
+        }
+        return this.handleFrame(a1, a0, r8);
+      }
+      if (RPCOpcodes.CLOSE === r11) {
+        if (a0 == null) {
+          throw new RPCError({
+            closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+          }, "Not connected");
+        }
+        return this.handleClose(a0, r8);
+      }
+      throw new RPCError({
+        closeCode: RPCCloseCodes.CLOSE_UNSUPPORTED
+      }, "Invalid opcode");
+    }
+  }
+}
+export default PostMessageTransport;