yeet

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;