@metamask/snaps-rpc-methods 3.1.0

package/dist/types/restricted/dialog.d.ts

@@ -0,0 +1,113 @@
+import type { PermissionSpecificationBuilder, RestrictedMethodOptions } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { Component } from '@metamask/snaps-ui';
+import type { EnumToUnion } from '@metamask/snaps-utils';
+import type { NonEmptyArray } from '@metamask/utils';
+import type { Infer, Struct } from 'superstruct';
+import type { MethodHooksObject } from '../utils';
+declare const methodName = "snap_dialog";
+export declare enum DialogType {
+    Alert = "alert",
+    Confirmation = "confirmation",
+    Prompt = "prompt"
+}
+declare const PlaceholderStruct: Struct<string | undefined, null>;
+export declare type Placeholder = Infer<typeof PlaceholderStruct>;
+declare type ShowDialog = (snapId: string, type: EnumToUnion<DialogType>, content: Component, placeholder?: Placeholder) => Promise<null | boolean | string>;
+export declare type DialogMethodHooks = {
+    /**
+     * @param snapId - The ID of the Snap that created the alert.
+     * @param type - The dialog type.
+     * @param content - The dialog custom UI.
+     * @param placeholder - The placeholder for the Prompt dialog input.
+     */
+    showDialog: ShowDialog;
+};
+declare type DialogSpecificationBuilderOptions = {
+    allowedCaveats?: Readonly<NonEmptyArray<string>> | null;
+    methodHooks: DialogMethodHooks;
+};
+export declare const dialogBuilder: Readonly<{
+    readonly targetName: "snap_dialog";
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.RestrictedMethod, DialogSpecificationBuilderOptions, {
+        permissionType: PermissionType.RestrictedMethod;
+        targetName: typeof methodName;
+        methodImplementation: ReturnType<typeof getDialogImplementation>;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+    }>;
+    readonly methodHooks: MethodHooksObject<DialogMethodHooks>;
+}>;
+declare const DialogParametersStruct: Struct<{
+    type: "alert";
+    content: import("@metamask/snaps-ui").Panel | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Copyable;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Divider;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Heading;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Spinner;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Text;
+        markdown?: boolean | undefined;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Image;
+    };
+} | {
+    type: "confirmation";
+    content: import("@metamask/snaps-ui").Panel | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Copyable;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Divider;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Heading;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Spinner;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Text;
+        markdown?: boolean | undefined;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Image;
+    };
+} | {
+    type: "prompt";
+    content: import("@metamask/snaps-ui").Panel | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Copyable;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Divider;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Heading;
+    } | {
+        type: import("@metamask/snaps-ui").NodeType.Spinner;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Text;
+        markdown?: boolean | undefined;
+    } | {
+        value: string;
+        type: import("@metamask/snaps-ui").NodeType.Image;
+    };
+    placeholder?: string | undefined;
+}, null>;
+export declare type DialogParameters = Infer<typeof DialogParametersStruct>;
+/**
+ * Builds the method implementation for `snap_dialog`.
+ *
+ * @param hooks - The RPC method hooks.
+ * @param hooks.showDialog - A function that shows the specified dialog in the
+ * MetaMask UI and returns the appropriate value for the dialog type.
+ * @returns The method implementation which return value depends on the dialog
+ * type, valid return types are: string, boolean, null.
+ */
+export declare function getDialogImplementation({ showDialog }: DialogMethodHooks): (args: RestrictedMethodOptions<DialogParameters>) => Promise<boolean | null | string>;
+export {};

package/dist/types/restricted/getBip32Entropy.d.ts

@@ -0,0 +1,45 @@
+import type { JsonSLIP10Node } from '@metamask/key-tree';
+import type { PermissionSpecificationBuilder, PermissionValidatorConstraint, RestrictedMethodOptions } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { Bip32Entropy } from '@metamask/snaps-utils';
+import type { NonEmptyArray } from '@metamask/utils';
+import type { MethodHooksObject } from '../utils';
+declare const targetName = "snap_getBip32Entropy";
+export declare type GetBip32EntropyMethodHooks = {
+    /**
+     * @returns The mnemonic of the user's primary keyring.
+     */
+    getMnemonic: () => Promise<Uint8Array>;
+    /**
+     * Waits for the extension to be unlocked.
+     *
+     * @returns A promise that resolves once the extension is unlocked.
+     */
+    getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;
+};
+declare type GetBip32EntropySpecificationBuilderOptions = {
+    methodHooks: GetBip32EntropyMethodHooks;
+};
+export declare const getBip32EntropyBuilder: Readonly<{
+    readonly targetName: "snap_getBip32Entropy";
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.RestrictedMethod, GetBip32EntropySpecificationBuilderOptions, {
+        permissionType: PermissionType.RestrictedMethod;
+        targetName: typeof targetName;
+        methodImplementation: ReturnType<typeof getBip32EntropyImplementation>;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+    }>;
+    readonly methodHooks: MethodHooksObject<GetBip32EntropyMethodHooks>;
+}>;
+/**
+ * Builds the method implementation for `snap_getBip32Entropy`.
+ *
+ * @param hooks - The RPC method hooks.
+ * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.
+ * @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked
+ * and prompts the user to unlock their MetaMask if it is locked.
+ * @returns The method implementation which returns a `JsonSLIP10Node`.
+ * @throws If the params are invalid.
+ */
+export declare function getBip32EntropyImplementation({ getMnemonic, getUnlockPromise, }: GetBip32EntropyMethodHooks): (args: RestrictedMethodOptions<Bip32Entropy>) => Promise<JsonSLIP10Node>;
+export {};

package/dist/types/restricted/getBip32PublicKey.d.ts

@@ -0,0 +1,60 @@
+import type { PermissionSpecificationBuilder, PermissionValidatorConstraint, RestrictedMethodOptions } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { NonEmptyArray } from '@metamask/utils';
+import type { MethodHooksObject } from '../utils';
+declare const targetName = "snap_getBip32PublicKey";
+export declare type GetBip32PublicKeyMethodHooks = {
+    /**
+     * @returns The mnemonic of the user's primary keyring.
+     */
+    getMnemonic: () => Promise<Uint8Array>;
+    /**
+     * Waits for the extension to be unlocked.
+     *
+     * @returns A promise that resolves once the extension is unlocked.
+     */
+    getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;
+};
+declare type GetBip32PublicKeySpecificationBuilderOptions = {
+    methodHooks: GetBip32PublicKeyMethodHooks;
+};
+declare type GetBip32PublicKeyParameters = {
+    path: ['m', ...(`${number}` | `${number}'`)[]];
+    curve: 'secp256k1' | 'ed25519';
+    compressed?: boolean;
+};
+export declare const Bip32PublicKeyArgsStruct: import("superstruct").Struct<{
+    path: string[];
+    curve: "ed25519" | "secp256k1";
+    compressed?: boolean | undefined;
+}, {
+    path: import("superstruct").Struct<string[], import("superstruct").Struct<string, null>>;
+    curve: import("superstruct").Struct<"ed25519" | "secp256k1", {
+        ed25519: "ed25519";
+        secp256k1: "secp256k1";
+    }>;
+    compressed: import("superstruct").Struct<boolean | undefined, null>;
+}>;
+export declare const getBip32PublicKeyBuilder: Readonly<{
+    readonly targetName: "snap_getBip32PublicKey";
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.RestrictedMethod, GetBip32PublicKeySpecificationBuilderOptions, {
+        permissionType: PermissionType.RestrictedMethod;
+        targetName: typeof targetName;
+        methodImplementation: ReturnType<typeof getBip32PublicKeyImplementation>;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+    }>;
+    readonly methodHooks: MethodHooksObject<GetBip32PublicKeyMethodHooks>;
+}>;
+/**
+ * Builds the method implementation for `snap_getBip32PublicKey`.
+ *
+ * @param hooks - The RPC method hooks.
+ * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase of the user.
+ * @param hooks.getUnlockPromise - A function that resolves once the MetaMask extension is unlocked
+ * and prompts the user to unlock their MetaMask if it is locked.
+ * @returns The method implementation which returns a public key.
+ * @throws If the params are invalid.
+ */
+export declare function getBip32PublicKeyImplementation({ getMnemonic, getUnlockPromise, }: GetBip32PublicKeyMethodHooks): (args: RestrictedMethodOptions<GetBip32PublicKeyParameters>) => Promise<string>;
+export {};

package/dist/types/restricted/getBip44Entropy.d.ts

@@ -0,0 +1,49 @@
+import type { JsonBIP44CoinTypeNode } from '@metamask/key-tree';
+import type { PermissionSpecificationBuilder, PermissionValidatorConstraint, RestrictedMethodOptions } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { NonEmptyArray } from '@metamask/utils';
+import type { MethodHooksObject } from '../utils';
+declare const targetName = "snap_getBip44Entropy";
+export declare type GetBip44EntropyMethodHooks = {
+    /**
+     * @returns The mnemonic of the user's primary keyring.
+     */
+    getMnemonic: () => Promise<Uint8Array>;
+    /**
+     * Waits for the extension to be unlocked.
+     *
+     * @returns A promise that resolves once the extension is unlocked.
+     */
+    getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;
+};
+declare type GetBip44EntropySpecificationBuilderOptions = {
+    methodHooks: GetBip44EntropyMethodHooks;
+};
+export declare type GetBip44EntropyParams = {
+    coinType: number;
+};
+export declare const getBip44EntropyBuilder: Readonly<{
+    readonly targetName: "snap_getBip44Entropy";
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.RestrictedMethod, GetBip44EntropySpecificationBuilderOptions, {
+        permissionType: PermissionType.RestrictedMethod;
+        targetName: typeof targetName;
+        methodImplementation: ReturnType<typeof getBip44EntropyImplementation>;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+    }>;
+    readonly methodHooks: MethodHooksObject<GetBip44EntropyMethodHooks>;
+}>;
+/**
+ * Builds the method implementation for `snap_getBip44Entropy`.
+ *
+ * @param hooks - The RPC method hooks.
+ * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase
+ * of the user.
+ * @param hooks.getUnlockPromise - A function that resolves once the MetaMask
+ * extension is unlocked and prompts the user to unlock their MetaMask if it is
+ * locked.
+ * @returns The method implementation which returns a `BIP44CoinTypeNode`.
+ * @throws If the params are invalid.
+ */
+export declare function getBip44EntropyImplementation({ getMnemonic, getUnlockPromise, }: GetBip44EntropyMethodHooks): (args: RestrictedMethodOptions<GetBip44EntropyParams>) => Promise<JsonBIP44CoinTypeNode>;
+export {};

package/dist/types/restricted/getEntropy.d.ts

@@ -0,0 +1,60 @@
+import type { PermissionSpecificationBuilder, RestrictedMethodOptions } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { Hex, NonEmptyArray } from '@metamask/utils';
+import type { Infer } from 'superstruct';
+import type { MethodHooksObject } from '../utils';
+declare const targetName = "snap_getEntropy";
+declare type GetEntropySpecificationBuilderOptions = {
+    allowedCaveats?: Readonly<NonEmptyArray<string>> | null;
+    methodHooks: GetEntropyHooks;
+};
+export declare const GetEntropyArgsStruct: import("superstruct").Struct<{
+    version: 1;
+    salt?: string | undefined;
+}, {
+    version: import("superstruct").Struct<1, 1>;
+    salt: import("superstruct").Struct<string | undefined, null>;
+}>;
+/**
+ * @property version - The version of the `snap_getEntropy` method. This must be
+ * the numeric literal `1`.
+ * @property salt - A string to use as the salt when deriving the entropy. If
+ * omitted, the salt will be an empty string.
+ */
+export declare type GetEntropyArgs = Infer<typeof GetEntropyArgsStruct>;
+export declare const getEntropyBuilder: Readonly<{
+    readonly targetName: "snap_getEntropy";
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.RestrictedMethod, GetEntropySpecificationBuilderOptions, {
+        permissionType: PermissionType.RestrictedMethod;
+        targetName: typeof targetName;
+        methodImplementation: ReturnType<typeof getEntropyImplementation>;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+    }>;
+    readonly methodHooks: MethodHooksObject<GetEntropyHooks>;
+}>;
+export declare type GetEntropyHooks = {
+    /**
+     * @returns The mnemonic of the user's primary keyring.
+     */
+    getMnemonic: () => Promise<Uint8Array>;
+    /**
+     * Waits for the extension to be unlocked.
+     *
+     * @returns A promise that resolves once the extension is unlocked.
+     */
+    getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;
+};
+/**
+ * Builds the method implementation for `snap_getEntropy`. The implementation
+ * is based on the reference implementation of
+ * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).
+ *
+ * @param hooks - The RPC method hooks.
+ * @param hooks.getMnemonic - The method to get the mnemonic of the user's
+ * primary keyring.
+ * @param hooks.getUnlockPromise - The method to get a promise that resolves
+ * once the extension is unlocked.
+ * @returns The method implementation.
+ */
+declare function getEntropyImplementation({ getMnemonic, getUnlockPromise, }: GetEntropyHooks): (options: RestrictedMethodOptions<GetEntropyArgs>) => Promise<Hex>;
+export {};

package/dist/types/restricted/getLocale.d.ts

@@ -0,0 +1,47 @@
+import type { PermissionSpecificationBuilder, ValidPermissionSpecification, RestrictedMethodOptions, RestrictedMethodParameters } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { NonEmptyArray } from '@metamask/utils';
+import type { MethodHooksObject } from '../utils';
+declare const methodName = "snap_getLocale";
+export declare type GetLocaleMethodHooks = {
+    getLocale: () => Promise<string>;
+};
+declare type SpecificationBuilderOptions = {
+    allowedCaveats?: Readonly<NonEmptyArray<string>> | null;
+    methodHooks: GetLocaleMethodHooks;
+};
+declare type Specification = ValidPermissionSpecification<{
+    permissionType: PermissionType.RestrictedMethod;
+    targetName: typeof methodName;
+    methodImplementation: ReturnType<typeof getImplementation>;
+    allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+}>;
+/**
+ * The specification builder for the `snap_getLocale` permission.
+ * `snap_getLocale` allows snaps to get the user selected locale.
+ *
+ * @param options - The specification builder options.
+ * @param options.allowedCaveats - The optional allowed caveats for the permission.
+ * @param options.methodHooks - The RPC method hooks needed by the method implementation.
+ * @returns The specification for the `snap_getLocale` permission.
+ */
+export declare const specificationBuilder: PermissionSpecificationBuilder<PermissionType.RestrictedMethod, SpecificationBuilderOptions, Specification>;
+export declare const getLocaleBuilder: Readonly<{
+    readonly targetName: "snap_getLocale";
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.RestrictedMethod, SpecificationBuilderOptions, {
+        permissionType: PermissionType.RestrictedMethod;
+        targetName: typeof methodName;
+        methodImplementation: ReturnType<typeof getImplementation>;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+    }>;
+    readonly methodHooks: MethodHooksObject<GetLocaleMethodHooks>;
+}>;
+/**
+ * Builds the method implementation for `snap_getLocale`.
+ *
+ * @param hooks - The RPC method hooks.
+ * @param hooks.getLocale - A function that returns the user selected locale.
+ * @returns The user selected locale.
+ */
+export declare function getImplementation({ getLocale }: GetLocaleMethodHooks): (_args: RestrictedMethodOptions<RestrictedMethodParameters>) => Promise<string>;
+export {};

package/dist/types/restricted/index.d.ts

@@ -0,0 +1,232 @@
+import type { DialogMethodHooks } from './dialog';
+import type { GetBip32EntropyMethodHooks } from './getBip32Entropy';
+import type { GetBip32PublicKeyMethodHooks } from './getBip32PublicKey';
+import type { GetBip44EntropyMethodHooks } from './getBip44Entropy';
+import type { GetEntropyHooks } from './getEntropy';
+import type { GetLocaleMethodHooks } from './getLocale';
+import type { InvokeSnapMethodHooks } from './invokeSnap';
+import type { ManageAccountsMethodHooks } from './manageAccounts';
+import type { ManageStateMethodHooks } from './manageState';
+import type { NotifyMethodHooks } from './notify';
+export type { DialogParameters } from './dialog';
+export { DialogType } from './dialog';
+export { ManageStateOperation } from './manageState';
+export { WALLET_SNAP_PERMISSION_KEY } from './invokeSnap';
+export type { NotificationArgs } from './notify';
+export { NotificationType } from './notify';
+export declare type RestrictedMethodHooks = DialogMethodHooks & GetBip32EntropyMethodHooks & GetBip32PublicKeyMethodHooks & GetBip44EntropyMethodHooks & GetEntropyHooks & InvokeSnapMethodHooks & ManageStateMethodHooks & NotifyMethodHooks & ManageAccountsMethodHooks & GetLocaleMethodHooks;
+export declare const restrictedMethodPermissionBuilders: {
+    readonly snap_dialog: Readonly<{
+        readonly targetName: "snap_dialog";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            allowedCaveats?: readonly [string, ...string[]] | null | undefined;
+            methodHooks: DialogMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_dialog";
+            methodImplementation: (args: import("@metamask/permission-controller").RestrictedMethodOptions<{
+                type: "alert";
+                content: import("@metamask/snaps-ui").Panel | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Copyable;
+                } | {
+                    type: import("@metamask/snaps-ui").NodeType.Divider;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Heading;
+                } | {
+                    type: import("@metamask/snaps-ui").NodeType.Spinner;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Text;
+                    markdown?: boolean | undefined;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Image;
+                };
+            } | {
+                type: "confirmation";
+                content: import("@metamask/snaps-ui").Panel | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Copyable;
+                } | {
+                    type: import("@metamask/snaps-ui").NodeType.Divider;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Heading;
+                } | {
+                    type: import("@metamask/snaps-ui").NodeType.Spinner;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Text;
+                    markdown?: boolean | undefined;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Image;
+                };
+            } | {
+                type: "prompt";
+                content: import("@metamask/snaps-ui").Panel | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Copyable;
+                } | {
+                    type: import("@metamask/snaps-ui").NodeType.Divider;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Heading;
+                } | {
+                    type: import("@metamask/snaps-ui").NodeType.Spinner;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Text;
+                    markdown?: boolean | undefined;
+                } | {
+                    value: string;
+                    type: import("@metamask/snaps-ui").NodeType.Image;
+                };
+                placeholder?: string | undefined;
+            }>) => Promise<string | boolean | null>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<DialogMethodHooks>;
+    }>;
+    readonly snap_getBip32Entropy: Readonly<{
+        readonly targetName: "snap_getBip32Entropy";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            methodHooks: GetBip32EntropyMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_getBip32Entropy";
+            methodImplementation: (args: import("@metamask/permission-controller").RestrictedMethodOptions<{
+                path: string[];
+                curve: "ed25519" | "secp256k1";
+            }>) => Promise<import("@metamask/key-tree").JsonSLIP10Node>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<GetBip32EntropyMethodHooks>;
+    }>;
+    readonly snap_getBip32PublicKey: Readonly<{
+        readonly targetName: "snap_getBip32PublicKey";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            methodHooks: GetBip32PublicKeyMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_getBip32PublicKey";
+            methodImplementation: (args: import("@metamask/permission-controller").RestrictedMethodOptions<{
+                path: ["m", ...(`${number}` | `${number}'`)[]];
+                curve: "ed25519" | "secp256k1";
+                compressed?: boolean | undefined;
+            }>) => Promise<string>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<GetBip32PublicKeyMethodHooks>;
+    }>;
+    readonly snap_getBip44Entropy: Readonly<{
+        readonly targetName: "snap_getBip44Entropy";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            methodHooks: GetBip44EntropyMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_getBip44Entropy";
+            methodImplementation: (args: import("@metamask/permission-controller").RestrictedMethodOptions<import("./getBip44Entropy").GetBip44EntropyParams>) => Promise<import("@metamask/key-tree").JsonBIP44CoinTypeNode>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<GetBip44EntropyMethodHooks>;
+    }>;
+    readonly snap_getEntropy: Readonly<{
+        readonly targetName: "snap_getEntropy";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            allowedCaveats?: readonly [string, ...string[]] | null | undefined;
+            methodHooks: GetEntropyHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_getEntropy";
+            methodImplementation: (options: import("@metamask/permission-controller").RestrictedMethodOptions<{
+                version: 1;
+                salt?: string | undefined;
+            }>) => Promise<`0x${string}`>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<GetEntropyHooks>;
+    }>;
+    readonly wallet_snap: Readonly<{
+        readonly targetName: "wallet_snap";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            allowedCaveats?: readonly [string, ...string[]] | null | undefined;
+            methodHooks: InvokeSnapMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "wallet_snap";
+            methodImplementation: (options: import("@metamask/permission-controller").RestrictedMethodOptions<Record<string, import("@metamask/utils").Json>>) => Promise<import("@metamask/utils").Json>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+            sideEffect: {
+                onPermitted: import("@metamask/permission-controller").SideEffectHandler<import("./invokeSnap").InstallSnaps | import("./invokeSnap").GetPermittedSnaps, never>;
+            };
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<InvokeSnapMethodHooks>;
+    }>;
+    readonly snap_manageState: Readonly<{
+        readonly targetName: "snap_manageState";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            allowedCaveats?: readonly [string, ...string[]] | null | undefined;
+            methodHooks: ManageStateMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_manageState";
+            methodImplementation: (options: import("@metamask/permission-controller").RestrictedMethodOptions<import("./manageState").ManageStateArgs>) => Promise<Record<string, import("@metamask/utils").Json> | null>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<ManageStateMethodHooks>;
+    }>;
+    readonly snap_notify: Readonly<{
+        readonly targetName: "snap_notify";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            allowedCaveats?: readonly [string, ...string[]] | null | undefined;
+            methodHooks: NotifyMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_notify";
+            methodImplementation: (args: import("@metamask/permission-controller").RestrictedMethodOptions<import("./notify").NotificationArgs>) => Promise<null>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<NotifyMethodHooks>;
+    }>;
+    readonly snap_manageAccounts: Readonly<{
+        readonly targetName: "snap_manageAccounts";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            allowedCaveats?: readonly [string, ...string[]] | null | undefined;
+            methodHooks: ManageAccountsMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_manageAccounts";
+            methodImplementation: (options: import("@metamask/permission-controller").RestrictedMethodOptions<{
+                method: string;
+            } | {
+                params: Record<string, import("@metamask/utils").Json> | import("@metamask/utils").Json[];
+                method: string;
+            }>) => Promise<import("@metamask/utils").Json>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+        readonly methodHooks: {
+            readonly getSnapKeyring: true;
+        };
+    }>;
+    readonly snap_getLocale: Readonly<{
+        readonly targetName: "snap_getLocale";
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.RestrictedMethod, {
+            allowedCaveats?: readonly [string, ...string[]] | null | undefined;
+            methodHooks: GetLocaleMethodHooks;
+        }, {
+            permissionType: import("@metamask/permission-controller").PermissionType.RestrictedMethod;
+            targetName: "snap_getLocale";
+            methodImplementation: (_args: import("@metamask/permission-controller").RestrictedMethodOptions<import("@metamask/permission-controller").RestrictedMethodParameters>) => Promise<string>;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+        readonly methodHooks: import("../utils").MethodHooksObject<GetLocaleMethodHooks>;
+    }>;
+};
+export * from './caveats';