@metamask/snaps-jest 4.0.1 → 6.0.0

package/dist/types/internals/request.d.ts

@@ -1,81 +1,45 @@
-import { HandlerType } from '@metamask/snaps-utils';
-import type { Page } from 'puppeteer';
-import type { CronjobOptions, RequestOptions, SnapRequest, TransactionOptions } from '../types';
+import type { AbstractExecutionService } from '@metamask/snaps-controllers';
+import type { SnapId, Component } from '@metamask/snaps-sdk';
+import type { HandlerType } from '@metamask/snaps-utils';
+import type { RequestOptions, SnapRequest } from '../types';
+import type { RunSagaFunction, Store } from './simulation';
+import type { RootControllerMessenger } from './simulation/controllers';
+export declare type HandleRequestOptions = {
+    snapId: SnapId;
+    store: Store;
+    executionService: AbstractExecutionService<unknown>;
+    handler: HandlerType;
+    controllerMessenger: RootControllerMessenger;
+    runSaga: RunSagaFunction;
+    request: RequestOptions;
+};
 /**
- * Send a request to the snap.
+ * Send a JSON-RPC request to the Snap, and wrap the response in a
+ * {@link SnapResponse} object.
  *
- * @param page - The page to send the request from.
  * @param options - The request options.
- * @param options.origin - The origin of the request. Defaults to `metamask.io`.
- * @param handler - The handler to use. Defaults to `onRpcRequest`.
- * @returns The response.
+ * @param options.snapId - The ID of the Snap to send the request to.
+ * @param options.store - The Redux store.
+ * @param options.executionService - The execution service to use to send the
+ * request.
+ * @param options.handler - The handler to use to send the request.
+ * @param options.controllerMessenger - The controller messenger used to call actions.
+ * @param options.runSaga - A function to run a saga outside the usual Redux
+ * flow.
+ * @param options.request - The request to send.
+ * @param options.request.id - The ID of the request. If not provided, a random
+ * ID will be generated.
+ * @param options.request.origin - The origin of the request. Defaults to
+ * `https://metamask.io`.
+ * @returns The response, wrapped in a {@link SnapResponse} object.
  */
-export declare function request(page: Page, { origin, ...options }: RequestOptions, handler?: HandlerType.OnRpcRequest | HandlerType.OnCronjob): SnapRequest;
+export declare function handleRequest({ snapId, store, executionService, handler, controllerMessenger, runSaga, request: { id, origin, ...options }, }: HandleRequestOptions): SnapRequest;
 /**
- * Send a transaction to the snap.
+ * Get the response content either from the SnapInterfaceController or the response object if there is one.
  *
- * @param page - The page to send the transaction from.
- * @param options - The transaction options.
- * @returns The response.
+ * @param result - The handler result object.
+ * @param snapId - The Snap ID.
+ * @param controllerMessenger - The controller messenger.
+ * @returns The content components if any.
  */
-export declare function sendTransaction(page: Page, options: Partial<TransactionOptions>): Promise<{
-    id: string;
-    response: ({
-        result: import("@metamask/snaps-sdk").Json;
-    } | {
-        error: import("@metamask/snaps-sdk").Json;
-    }) & Record<"error", unknown>;
-    notifications: never[];
-    content?: undefined;
-} | {
-    id: string;
-    response: {
-        result: import("@metamask/snaps-sdk").Json;
-    };
-    notifications: never[];
-    content: import("@metamask/snaps-sdk").Panel | {
-        value: string;
-        type: import("@metamask/snaps-sdk").NodeType.Copyable;
-        sensitive?: boolean | undefined;
-    } | {
-        type: import("@metamask/snaps-sdk").NodeType.Divider;
-    } | {
-        value: string;
-        type: import("@metamask/snaps-sdk").NodeType.Heading;
-    } | {
-        value: string;
-        type: import("@metamask/snaps-sdk").NodeType.Image;
-    } | {
-        type: import("@metamask/snaps-sdk").NodeType.Spinner;
-    } | {
-        value: string;
-        type: import("@metamask/snaps-sdk").NodeType.Text;
-        markdown?: boolean | undefined;
-    } | {
-        value: string;
-        type: import("@metamask/snaps-sdk").NodeType.Address;
-    } | {
-        value: {
-            value: string;
-            type: import("@metamask/snaps-sdk").NodeType.Image;
-        } | {
-            value: string;
-            type: import("@metamask/snaps-sdk").NodeType.Text;
-            markdown?: boolean | undefined;
-        } | {
-            value: string;
-            type: import("@metamask/snaps-sdk").NodeType.Address;
-        };
-        type: import("@metamask/snaps-sdk").NodeType.Row;
-        label: string;
-        variant?: "default" | "warning" | "critical" | undefined;
-    };
-}>;
-/**
- * Run a cronjob.
- *
- * @param page - The page to run the cronjob from.
- * @param options - The request options.
- * @returns The response.
- */
-export declare function runCronjob(page: Page, options: CronjobOptions): SnapRequest;
+export declare function getContentFromResult(result: unknown, snapId: SnapId, controllerMessenger: RootControllerMessenger): Component | undefined;

package/dist/types/internals/simulation/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A secret recovery phrase that is used for testing purposes. Do not use this
+ * to store any real funds!
+ */
+export declare const DEFAULT_SRP = "test test test test test test test test test test test ball";
+/**
+ * The default locale.
+ */
+export declare const DEFAULT_LOCALE = "en";
+/**
+ * The default JSON-RPC endpoint for Ethereum requests.
+ */
+export declare const DEFAULT_JSON_RPC_ENDPOINT = "https://cloudflare-eth.com/";

package/dist/types/internals/simulation/controllers.d.ts

@@ -0,0 +1,40 @@
+import type { ControllerMessenger } from '@metamask/base-controller';
+import type { CaveatSpecificationConstraint, PermissionSpecificationConstraint, PermissionControllerActions, SubjectMetadataControllerActions } from '@metamask/permission-controller';
+import { PermissionController, SubjectMetadataController } from '@metamask/permission-controller';
+import { SnapInterfaceController } from '@metamask/snaps-controllers';
+import type { ExecutionServiceActions, SnapInterfaceControllerActions, SnapInterfaceControllerAllowedActions } from '@metamask/snaps-controllers';
+import type { SnapId } from '@metamask/snaps-sdk';
+import type { SnapManifest } from '@metamask/snaps-utils';
+import type { SimulationOptions } from './options';
+import type { MiddlewareHooks } from './simulation';
+import type { RunSagaFunction } from './store';
+export declare type RootControllerAllowedActions = SnapInterfaceControllerActions | SnapInterfaceControllerAllowedActions | PermissionControllerActions | ExecutionServiceActions | SubjectMetadataControllerActions;
+export declare type RootControllerMessenger = ControllerMessenger<RootControllerAllowedActions, any>;
+export declare type GetControllersOptions = {
+    controllerMessenger: ControllerMessenger<any, any>;
+    hooks: MiddlewareHooks;
+    runSaga: RunSagaFunction;
+    options: SimulationOptions;
+};
+export declare type Controllers = {
+    permissionController: PermissionController<PermissionSpecificationConstraint, CaveatSpecificationConstraint>;
+    subjectMetadataController: SubjectMetadataController;
+    interfaceController: SnapInterfaceController;
+};
+/**
+ * Get the controllers for the Snap.
+ *
+ * @param options - The options.
+ * @returns The controllers for the Snap.
+ */
+export declare function getControllers(options: GetControllersOptions): Controllers;
+/**
+ * Register the Snap. This sets up the Snap's permissions and subject metadata.
+ *
+ * @param snapId - The ID of the Snap to install.
+ * @param manifest - The parsed manifest.
+ * @param controllers - The controllers for the Snap.
+ * @param controllers.permissionController - The permission controller.
+ * @param controllers.subjectMetadataController - The subject metadata controller.
+ */
+export declare function registerSnap(snapId: SnapId, manifest: SnapManifest, { permissionController, subjectMetadataController, }: Omit<Controllers, 'interfaceController'>): Promise<void>;

package/dist/types/internals/simulation/files.d.ts

@@ -0,0 +1,11 @@
+import { AuxiliaryFileEncoding } from '@metamask/snaps-sdk';
+import type { VirtualFile } from '@metamask/snaps-utils';
+/**
+ * Get a statically defined Snap file from an array of files.
+ *
+ * @param files - The Snap files.
+ * @param path - The file path.
+ * @param encoding - The requested file encoding.
+ * @returns The file in the requested encoding if found, otherwise null.
+ */
+export declare function getSnapFile(files: VirtualFile[], path: string, encoding?: AuxiliaryFileEncoding): Promise<string | null>;

package/dist/types/internals/simulation/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './interface';
+export * from './simulation';
+export * from './options';
+export * from './store';

package/dist/types/internals/simulation/interface.d.ts

@@ -0,0 +1,25 @@
+import type { Component, SnapId } from '@metamask/snaps-sdk';
+import { DialogType } from '@metamask/snaps-sdk';
+import type { SagaIterator } from 'redux-saga';
+import type { SnapInterface } from '../../types';
+import type { RootControllerMessenger } from './controllers';
+import type { RunSagaFunction } from './store';
+/**
+ * Get a user interface object from a type and content object.
+ *
+ * @param runSaga - A function to run a saga outside the usual Redux flow.
+ * @param type - The type of the interface.
+ * @param content - The content to show in the interface.
+ * @returns The user interface object.
+ */
+export declare function getInterfaceResponse(runSaga: RunSagaFunction, type: DialogType, content: Component): SnapInterface;
+/**
+ * Get a user interface object from a Snap.
+ *
+ * @param runSaga - A function to run a saga outside the usual Redux flow.
+ * @param snapId - The Snap ID.
+ * @param controllerMessenger - The controller messenger used to call actions.
+ * @yields Takes the set interface action.
+ * @returns The user interface object.
+ */
+export declare function getInterface(runSaga: RunSagaFunction, snapId: SnapId, controllerMessenger: RootControllerMessenger): SagaIterator<SnapInterface>;

package/dist/types/internals/simulation/methods/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const EXCLUDED_SNAP_ENDOWMENTS: never[];
+export declare const EXCLUDED_SNAP_PERMISSIONS: never[];
+/**
+ * All unrestricted methods recognized by the `PermissionController`.
+ * Unrestricted methods are ignored by the permission system, but every
+ * JSON-RPC request seen by the permission system must correspond to a
+ * restricted or unrestricted method, or the request will be rejected with a
+ * "method not found" error.
+ */
+export declare const UNRESTRICTED_METHODS: readonly string[];

package/dist/types/internals/simulation/methods/hooks/encryption.d.ts

@@ -0,0 +1,29 @@
+import type { Json } from '@metamask/utils';
+/**
+ * Mocks encrypting a value using a password. This is not a real encryption
+ * method, but rather is used to simulate encryption in the tests.
+ *
+ * Ideally we would use a real encryption method, such as
+ * `@metamask/browser-passworder`, but it doesn't seem to work with Node.js 18
+ * without some mocking. We can switch to a real encryption method once we
+ * drop support for Node.js 18.
+ *
+ * @param password - The password to use.
+ * @param value - The value to encrypt.
+ * @returns The "encrypted" value.
+ */
+export declare function encryptImplementation(password: string, value: Json): string;
+/**
+ * Mocks decrypting a value using a password. This is not a real encryption
+ * method, but rather is used to simulate encryption in the tests.
+ *
+ * Ideally we would use a real decryption method, such as
+ * `@metamask/browser-passworder`, but it doesn't seem to work with Node.js 18
+ * without some mocking. We can switch to a real encryption method once we
+ * drop support for Node.js 18.
+ *
+ * @param password - The password to use.
+ * @param value - The value to decrypt.
+ * @returns The "decrypted" value.
+ */
+export declare function decryptImplementation(password: string, value: string): any;

package/dist/types/internals/simulation/methods/hooks/get-locale.d.ts

@@ -0,0 +1,9 @@
+import type { SimulationOptions } from '../../options';
+/**
+ * Get the implementation of the `getLocale` hook.
+ *
+ * @param options - The simulation options.
+ * @param options.locale - The locale to use.
+ * @returns The implementation of the `getLocale` hook.
+ */
+export declare function getGetLocaleMethodImplementation({ locale, }: SimulationOptions): () => Promise<string>;

package/dist/types/internals/simulation/methods/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './encryption';
+export * from './get-locale';
+export * from './notifications';
+export * from './show-dialog';
+export * from './state';
+export * from './interface';

package/dist/types/internals/simulation/methods/hooks/interface.d.ts

@@ -0,0 +1,16 @@
+import type { Component, SnapId } from '@metamask/snaps-sdk';
+import type { RootControllerMessenger } from '../../controllers';
+/**
+ * Get the implementation of the `createInterface` hook.
+ *
+ * @param controllerMessenger - The controller messenger used to call actions.
+ * @returns The implementation of the `createInterface` hook.
+ */
+export declare function getCreateInterfaceImplementation(controllerMessenger: RootControllerMessenger): (snapId: SnapId, content: Component) => Promise<string>;
+/**
+ * Get the implementation of the `getInterface` hook.
+ *
+ * @param controllerMessenger - The controller messenger used to call actions.
+ * @returns The implementation of the `getInterface` hook.
+ */
+export declare function getGetInterfaceImplementation(controllerMessenger: RootControllerMessenger): (snapId: SnapId, id: string) => import("@metamask/snaps-controllers").StoredInterface;

package/dist/types/internals/simulation/methods/hooks/notifications.d.ts

@@ -0,0 +1,16 @@
+import type { NotifyParams } from '@metamask/snaps-sdk';
+import type { RunSagaFunction } from '../../store';
+/**
+ * Get a method that can be used to show a native notification.
+ *
+ * @param runSaga - A function to run a saga outside the usual Redux flow.
+ * @returns A method that can be used to show a native notification.
+ */
+export declare function getShowNativeNotificationImplementation(runSaga: RunSagaFunction): (args_0: string, args_1: NotifyParams) => Promise<any>;
+/**
+ * Get a method that can be used to show an in-app notification.
+ *
+ * @param runSaga - A function to run a saga outside the usual Redux flow.
+ * @returns A method that can be used to show an in-app notification.
+ */
+export declare function getShowInAppNotificationImplementation(runSaga: RunSagaFunction): (args_0: string, args_1: NotifyParams) => Promise<any>;

package/dist/types/internals/simulation/methods/hooks/show-dialog.d.ts

@@ -0,0 +1,9 @@
+import type { DialogType } from '@metamask/snaps-sdk';
+import type { RunSagaFunction } from '../../store';
+/**
+ * Get the implementation of the `showDialog` hook.
+ *
+ * @param runSaga - The function to run a saga outside the usual Redux flow.
+ * @returns The implementation of the `showDialog` hook.
+ */
+export declare function getShowDialogImplementation(runSaga: RunSagaFunction): (_snapId: string, type: DialogType, id: string, _placeholder?: string | undefined) => Promise<any>;

package/dist/types/internals/simulation/methods/hooks/state.d.ts

@@ -0,0 +1,22 @@
+import type { RunSagaFunction } from '../../store';
+/**
+ * Get the implementation of the `getSnapState` hook.
+ *
+ * @param runSaga - The function to run a saga outside the usual Redux flow.
+ * @returns The implementation of the `getSnapState` hook.
+ */
+export declare function getGetSnapStateMethodImplementation(runSaga: RunSagaFunction): (_snapId: string, encrypted?: boolean | undefined) => any;
+/**
+ * Get the implementation of the `updateSnapState` hook.
+ *
+ * @param runSaga - The function to run a saga outside the usual Redux flow.
+ * @returns The implementation of the `updateSnapState` hook.
+ */
+export declare function getUpdateSnapStateMethodImplementation(runSaga: RunSagaFunction): (_snapId: string, newState: string, encrypted?: boolean | undefined) => void;
+/**
+ * Get the implementation of the `clearSnapState` hook.
+ *
+ * @param runSaga - The function to run a saga outside the usual Redux flow.
+ * @returns The implementation of the `clearSnapState` hook.
+ */
+export declare function getClearSnapStateMethodImplementation(runSaga: RunSagaFunction): (_snapId: string, encrypted?: boolean | undefined) => Promise<void>;

package/dist/types/internals/simulation/methods/index.d.ts

@@ -0,0 +1 @@
+export * from './specifications';

package/dist/types/internals/simulation/methods/specifications.d.ts

@@ -0,0 +1,56 @@
+import type { GenericPermissionController } from '@metamask/permission-controller';
+import type { SnapId } from '@metamask/snaps-sdk';
+import type { RootControllerMessenger } from '../controllers';
+import type { SimulationOptions } from '../options';
+import type { RunSagaFunction } from '../store';
+export declare type PermissionSpecificationsHooks = {
+    /**
+     * A hook that returns the user's secret recovery phrase.
+     *
+     * @returns The user's secret recovery phrase.
+     */
+    getMnemonic: () => Promise<Uint8Array>;
+};
+export declare type GetPermissionSpecificationsOptions = {
+    controllerMessenger: RootControllerMessenger;
+    hooks: PermissionSpecificationsHooks;
+    runSaga: RunSagaFunction;
+    options: SimulationOptions;
+};
+/**
+ * Get a function which resolves with the specified result.
+ *
+ * @param result - The result to return.
+ * @returns The function implementation.
+ */
+export declare function resolve(result: unknown): () => unknown;
+/**
+ * Get a function which resolves with the specified result.
+ *
+ * @param result - The result to return. If not specified, the function will
+ * resolve with `undefined`.
+ * @returns The function implementation.
+ */
+export declare function asyncResolve(result?: unknown): () => Promise<unknown>;
+/**
+ * Get the permission specifications for the Snap.
+ *
+ * @param options - The options.
+ * @param options.controllerMessenger - The controller messenger.
+ * @param options.hooks - The hooks.
+ * @param options.runSaga - The function to run a saga outside the usual Redux
+ * flow.
+ * @param options.options - The simulation options.
+ * @returns The permission specifications for the Snap.
+ */
+export declare function getPermissionSpecifications({ controllerMessenger, hooks, runSaga, options, }: GetPermissionSpecificationsOptions): {
+    [x: string]: import("@metamask/permission-controller").PermissionSpecificationConstraint;
+};
+/**
+ * Get the endowments for the Snap.
+ *
+ * @param permissionController - The permission controller.
+ * @param snapId - The ID of the Snap.
+ * @returns The endowments for the Snap.
+ */
+export declare function getEndowments(permissionController: GenericPermissionController, snapId: SnapId): Promise<string[]>;

package/dist/types/internals/simulation/middleware/engine.d.ts

@@ -0,0 +1,26 @@
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import { JsonRpcEngine } from '@metamask/json-rpc-engine';
+import type { RestrictedMethodParameters } from '@metamask/permission-controller';
+import type { Json } from '@metamask/utils';
+import type { MiddlewareHooks } from '../simulation';
+import type { Store } from '../store';
+export declare type CreateJsonRpcEngineOptions = {
+    store: Store;
+    hooks: MiddlewareHooks;
+    permissionMiddleware: JsonRpcMiddleware<RestrictedMethodParameters, Json>;
+    endpoint?: string;
+};
+/**
+ * Create a JSON-RPC engine for use in a simulated environment. This engine
+ * should be used to handle all JSON-RPC requests. It is set up to handle
+ * requests that would normally be handled internally by the MetaMask client, as
+ * well as Snap-specific requests.
+ *
+ * @param options - The options to use when creating the engine.
+ * @param options.store - The Redux store to use.
+ * @param options.hooks - Any hooks used by the middleware handlers.
+ * @param options.permissionMiddleware - The permission middleware to use.
+ * @param options.endpoint - The JSON-RPC endpoint to use for Ethereum requests.
+ * @returns A JSON-RPC engine.
+ */
+export declare function createJsonRpcEngine({ store, hooks, permissionMiddleware, endpoint, }: CreateJsonRpcEngineOptions): JsonRpcEngine;

package/dist/types/internals/simulation/middleware/index.d.ts

@@ -0,0 +1 @@
+export * from './engine';

package/dist/types/internals/simulation/middleware/internal-methods/accounts.d.ts

@@ -0,0 +1,18 @@
+import type { JsonRpcEngineEndCallback, JsonRpcEngineNextCallback } from '@metamask/json-rpc-engine';
+import type { Json, JsonRpcRequest, PendingJsonRpcResponse } from '@metamask/utils';
+export declare type GetAccountsHandlerHooks = {
+    getMnemonic: () => Promise<Uint8Array>;
+};
+/**
+ * A mock handler for account related methods that always returns the first
+ * address for the selected secret recovery phrase.
+ *
+ * @param _request - Incoming JSON-RPC request. This is ignored for this
+ * specific handler.
+ * @param response - The outgoing JSON-RPC response, modified to return the
+ * result.
+ * @param _next - The `json-rpc-engine` middleware next handler.
+ * @param end - The `json-rpc-engine` middleware end handler.
+ * @param hooks - Any hooks required by this handler.
+ */
+export declare function getAccountsHandler(_request: JsonRpcRequest, response: PendingJsonRpcResponse<Json>, _next: JsonRpcEngineNextCallback, end: JsonRpcEngineEndCallback, hooks: GetAccountsHandlerHooks): Promise<void>;

package/dist/types/internals/simulation/middleware/internal-methods/index.d.ts

@@ -0,0 +1 @@
+export * from './middleware';

package/dist/types/internals/simulation/middleware/internal-methods/middleware.d.ts

@@ -0,0 +1,22 @@
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import type { Json, JsonRpcParams } from '@metamask/utils';
+export declare type InternalMethodsMiddlewareHooks = {
+    /**
+     * A hook that returns the user's secret recovery phrase.
+     *
+     * @returns The user's secret recovery phrase.
+     */
+    getMnemonic: () => Promise<Uint8Array>;
+};
+/**
+ * Create a middleware for handling JSON-RPC methods normally handled internally
+ * by the MetaMask client.
+ *
+ * NOTE: This middleware provides all `hooks` to all handlers and should
+ * therefore NOT be used outside of the simulation environment. It is intended
+ * for testing purposes only.
+ *
+ * @param hooks - Any hooks used by the middleware handlers.
+ * @returns A middleware function.
+ */
+export declare function createInternalMethodsMiddleware(hooks: InternalMethodsMiddlewareHooks): JsonRpcMiddleware<JsonRpcParams, Json>;

package/dist/types/internals/simulation/middleware/internal-methods/provider-state.d.ts

@@ -0,0 +1,14 @@
+import type { JsonRpcEngineEndCallback, JsonRpcEngineNextCallback } from '@metamask/json-rpc-engine';
+import type { Json, JsonRpcRequest, PendingJsonRpcResponse } from '@metamask/utils';
+/**
+ * A mock handler for metamask_getProviderState that always returns a specific
+ * hardcoded result.
+ *
+ * @param _request - Incoming JSON-RPC request. Ignored for this specific
+ * handler.
+ * @param response - The outgoing JSON-RPC response, modified to return the
+ * result.
+ * @param _next - The `json-rpc-engine` middleware next handler.
+ * @param end - The `json-rpc-engine` middleware end handler.
+ */
+export declare function getProviderStateHandler(_request: JsonRpcRequest, response: PendingJsonRpcResponse<Json>, _next: JsonRpcEngineNextCallback, end: JsonRpcEngineEndCallback): Promise<void>;

package/dist/types/internals/simulation/middleware/mock.d.ts

@@ -0,0 +1,10 @@
+import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
+import type { Json, JsonRpcParams } from '@metamask/utils';
+import type { Store } from '../store';
+/**
+ * Create a middleware for handling JSON-RPC methods that have been mocked.
+ *
+ * @param store - The Redux store to use.
+ * @returns A middleware function.
+ */
+export declare function createMockMiddleware(store: Store): JsonRpcMiddleware<JsonRpcParams, Json>;

package/dist/types/internals/simulation/options.d.ts

@@ -0,0 +1,37 @@
+import type { Infer } from 'superstruct';
+declare const SimulationOptionsStruct: import("superstruct").Struct<{
+    state?: Record<string, import("@metamask/utils").Json> | null | undefined;
+    locale?: string | undefined;
+    secretRecoveryPhrase?: string | undefined;
+    unencryptedState?: Record<string, import("@metamask/utils").Json> | null | undefined;
+}, {
+    secretRecoveryPhrase: import("superstruct").Struct<string | undefined, null>;
+    locale: import("superstruct").Struct<string | undefined, null>;
+    state: import("superstruct").Struct<Record<string, import("@metamask/utils").Json> | null | undefined, null>;
+    unencryptedState: import("superstruct").Struct<Record<string, import("@metamask/utils").Json> | null | undefined, null>;
+}>;
+/**
+ * Options for the simulation.
+ *
+ * @property secretRecoveryPhrase - The secret recovery phrase to use. This is
+ * used to derive addresses and private keys. Defaults to a test recovery
+ * phrase.
+ * @property locale - The locale to use. Defaults to `en`.
+ * @property state - The initial state of the Snap, if any. Defaults to `null`.
+ */
+export declare type SimulationUserOptions = Infer<typeof SimulationOptionsStruct>;
+/**
+ * Options for the simulation, with defaults filled in.
+ *
+ * See {@link SimulationUserOptions} for documentation.
+ */
+export declare type SimulationOptions = Required<SimulationUserOptions>;
+/**
+ * Get the options for the simulation.
+ *
+ * @param options - The user options. Any options not specified will be filled
+ * in with default values.
+ * @returns The simulation options.
+ */
+export declare function getOptions(options: SimulationUserOptions): SimulationOptions;
+export {};