chore!: Make interface actions synchronous (#3361)

Interface actions used to be required to be asynchronous, this is no
longer the case.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Convert Snap interface create/update flows from async to sync across
controllers, RPC handlers, simulation hooks, and tests.
> 
> - **Controllers**:
> - Make `SnapInterfaceController#createInterface`, `updateInterface`,
and private `#validateContent` synchronous; remove `await` usage.
> - **RPC Methods**:
> - Update `snap_createInterface` and `snap_updateInterface`
implementations and hook types to return synchronously (no `Promise`).
> - **Simulation**:
> - Make permitted hooks `createInterface`/`updateInterface`
synchronous; adjust `getInterfaceFromResult` to call controller without
`await`.
> - **Tests**:
> - Remove `await` from synchronous calls; switch async rejection
assertions to synchronous `.toThrow` where applicable; update usages
across controller, simulation, and request tests.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
c8e8a1b. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: FrederikBolding

packages/snaps-controllers/src/interface/SnapInterfaceController.test.tsx

@@ -277,14 +277,14 @@ export class SnapInterfaceController extends BaseController<
    * @param contentType - The type of content.
    * @returns The newly interface id.
    */
-  async createInterface(
+  createInterface(
     snapId: SnapId,
     content: ComponentOrElement,
     context?: InterfaceContext,
     contentType?: ContentType,
   ) {
     const element = getJsxInterface(content);
-    await this.#validateContent(element);
+    this.#validateContent(element);
     validateInterfaceContext(context);
 
     const id = nanoid();
@@ -333,15 +333,15 @@ export class SnapInterfaceController extends BaseController<
    * @param content - The new content.
    * @param context - An optional interface context object.
    */
-  async updateInterface(
+  updateInterface(
     snapId: SnapId,
     id: string,
     content: ComponentOrElement,
     context?: InterfaceContext,
   ) {
     this.#validateArgs(snapId, id);
     const element = getJsxInterface(content);
-    await this.#validateContent(element);
+    this.#validateContent(element);
     validateInterfaceContext(context);
 
     const oldState = this.state.interfaces[id].state;
@@ -543,7 +543,7 @@ export class SnapInterfaceController extends BaseController<
    *
    * @param element - The JSX element to verify.
    */
-  async #validateContent(element: JSXElement) {
+  #validateContent(element: JSXElement) {
     // We assume the validity of this JSON to be validated by the caller.
     // E.g., in the RPC method implementation.
     const size = getJsonSizeUnsafe(element);

packages/snaps-controllers/src/interface/SnapInterfaceController.ts

@@ -32,7 +32,7 @@ export type CreateInterfaceMethodHooks = {
     ui: ComponentOrElement,
     context?: InterfaceContext,
     contentType?: ContentType,
-  ) => Promise<string>;
+  ) => string;
 };
 
 export const createInterfaceHandler: PermittedHandlerExport<
@@ -67,21 +67,21 @@ export type CreateInterfaceParameters = InferMatching<
  * @param hooks.createInterface - The function to create the interface.
  * @returns Nothing.
  */
-async function getCreateInterfaceImplementation(
+function getCreateInterfaceImplementation(
   req: JsonRpcRequest<CreateInterfaceParameters>,
   res: PendingJsonRpcResponse<CreateInterfaceResult>,
   _next: unknown,
   end: JsonRpcEngineEndCallback,
   { createInterface }: CreateInterfaceMethodHooks,
-): Promise<void> {
+): void {
   const { params } = req;
 
   try {
     const validatedParams = getValidatedParams(params);
 
     const { ui, context } = validatedParams;
 
-    res.result = await createInterface(ui, context);
+    res.result = createInterface(ui, context);
   } catch (error) {
     return end(error);
   }

packages/snaps-rpc-methods/src/permitted/createInterface.ts

@@ -38,7 +38,7 @@ export type UpdateInterfaceMethodHooks = {
     id: string,
     ui: ComponentOrElement,
     context?: InterfaceContext,
-  ) => Promise<void>;
+  ) => void;
 };
 
 export const updateInterfaceHandler: PermittedHandlerExport<
@@ -74,21 +74,21 @@ export type UpdateInterfaceParameters = InferMatching<
  * @param hooks.updateInterface - The function to update the interface.
  * @returns Nothing.
  */
-async function getUpdateInterfaceImplementation(
+function getUpdateInterfaceImplementation(
   req: JsonRpcRequest<UpdateInterfaceParameters>,
   res: PendingJsonRpcResponse<UpdateInterfaceResult>,
   _next: unknown,
   end: JsonRpcEngineEndCallback,
   { updateInterface }: UpdateInterfaceMethodHooks,
-): Promise<void> {
+): void {
   const { params } = req;
 
   try {
     const validatedParams = getValidatedParams(params);
 
     const { id, ui, context } = validatedParams;
 
-    await updateInterface(id, ui, context);
+    updateInterface(id, ui, context);
     res.result = null;
   } catch (error) {
     return end(error);