@metamask/snaps-rpc-methods/dist/permitted/messengerCall.mjs

MetaMask Snaps JSON-RPC method implementations

import { rpcErrors } from "@metamask/rpc-errors";
import { create, object, StructError, array } from "@metamask/superstruct";
import { definePattern, JsonStruct } from "@metamask/utils";
import { SnapEndowments } from "../endowments/index.mjs";
import { getMessengerCaveatActions } from "../endowments/messenger.mjs";
const hookNames = {
    getMessenger: true,
};
const BLOCKED_MESSENGER_CLIENTS = [
    'ApprovalController',
    'KeyringController',
    'PermissionController',
    'SnapController',
    'WebSocketService',
    'CronjobController',
    'SnapInsightsController',
    'SnapInterfaceController',
    'MultichainRoutingService',
    'ExecutionService',
    'SnapRegistryController',
];
const MessengerCallParametersStruct = object({
    action: definePattern('MessengerAction', /^.+:.+$/u),
    params: array(JsonStruct),
});
/**
 * Handler for the `snap_messengerCall` method.
 *
 * @internal
 */
export const messengerCallHandler = {
    implementation: getMessengerCallImplementation,
    hookNames,
    actionNames: ['SnapController:getSnap', 'PermissionController:getPermission'],
};
/**
 * The `snap_messengerCall` method implementation. This method is used to dispatch
 * an action via the messenger. It is only available to preinstalled Snaps.
 *
 * @param request - The JSON-RPC request object.
 * @param response - The JSON-RPC response object.
 * @param _next - The `json-rpc-engine` "next" callback. Not used by this
 * function.
 * @param end - The `json-rpc-engine` "end" callback.
 * @param hooks - The RPC method hooks.
 * @param hooks.getMessenger - The hook function to create a custom messenger for the Snap.
 * @param messenger - The messenger used to call controller actions.
 * @returns Nothing.
 */
async function getMessengerCallImplementation(request, response, _next, end, { getMessenger }, messenger) {
    const snap = messenger.call('SnapController:getSnap', request.origin);
    const permission = messenger.call('PermissionController:getPermission', request.origin, SnapEndowments.Messenger);
    if (!snap?.preinstalled || !permission) {
        return end(rpcErrors.methodNotFound());
    }
    const actions = getMessengerCaveatActions(permission);
    const snapMessenger = getMessenger({ actions });
    const { params } = request;
    try {
        const { action, params: actionParams } = getValidatedParams(params);
        if (BLOCKED_MESSENGER_CLIENTS.some((namespace) => action.startsWith(namespace))) {
            return end(rpcErrors.invalidParams({
                message: `Access to the following messenger clients are disallowed in Snaps: ${BLOCKED_MESSENGER_CLIENTS.join(', ')}.`,
            }));
        }
        response.result = await snapMessenger.call(action, ...actionParams);
    }
    catch (error) {
        return end(error);
    }
    return end();
}
/**
 * Validate the parameters for the `snap_messengerCall` method.
 *
 * @param params - Parameters to validate.
 * @returns Validated parameters.
 * @throws Throws RPC error if validation fails.
 */
function getValidatedParams(params) {
    try {
        return create(params, MessengerCallParametersStruct);
    }
    catch (error) {
        if (error instanceof StructError) {
            throw rpcErrors.invalidParams({
                message: `Invalid params: ${error.message}.`,
            });
        }
        /* istanbul ignore next */
        throw rpcErrors.internal();
    }
}
//# sourceMappingURL=messengerCall.mjs.map