@metamask/snaps-rpc-methods 4.1.0 → 6.0.0

package/dist/types/endowments/caveats/generic.d.ts

@@ -0,0 +1,19 @@
+import type { PermissionConstraint, PermissionValidatorConstraint } from '@metamask/permission-controller';
+import type { Json } from '@metamask/utils';
+export declare type CaveatMapperReturnValue = Pick<PermissionConstraint, 'caveats'>;
+export declare type CaveatMapperFunction = (value: Json) => CaveatMapperReturnValue;
+/**
+ * Create a generic permission validator that validates the presence of certain caveats.
+ *
+ * This validator only validates the types of the caveats, not the values.
+ *
+ * @param caveatsToValidate - A list of objects that represent caveats.
+ * @param caveatsToValidate.type - The string defining the caveat type.
+ * @param caveatsToValidate.optional - An optional boolean flag that defines
+ * whether the caveat is optional or not.
+ * @returns A function that validates a permission.
+ */
+export declare function createGenericPermissionValidator(caveatsToValidate: {
+    type: string;
+    optional?: boolean;
+}[]): PermissionValidatorConstraint;

package/dist/types/endowments/caveats/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generic';
+export * from './requestTime';

package/dist/types/endowments/caveats/requestTime.d.ts

@@ -0,0 +1,29 @@
+import type { CaveatSpecificationConstraint, PermissionConstraint } from '@metamask/permission-controller';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+import type { Json } from '@metamask/utils';
+import type { CaveatMapperFunction, CaveatMapperReturnValue } from './generic';
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionsController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */
+export declare function getMaxRequestTimeCaveatMapper(value: Json): CaveatMapperReturnValue;
+/**
+ * Creates a wrapping caveat mapper that creates the `maxRequestTime` caveat
+ * and merges it with any other caveats created by the mapper function.
+ *
+ * @param mapper - Another caveat mapper function.
+ * @returns The caveat specification.
+ */
+export declare function createMaxRequestTimeMapper(mapper: CaveatMapperFunction): CaveatMapperFunction;
+/**
+ * Getter function to get the {@link MaxRequestTime} caveat value from a permission if specified.
+ *
+ * @param permission - The permission to get the caveat value from.
+ * @returns The caveat value if present, otherwise null.
+ */
+export declare function getMaxRequestTimeCaveat(permission?: PermissionConstraint): number | null;
+export declare const maxRequestTimeCaveatSpecifications: Record<SnapCaveatType.MaxRequestTime, CaveatSpecificationConstraint>;

package/dist/types/endowments/cronjob.d.ts

@@ -0,0 +1,51 @@
+import type { PermissionSpecificationBuilder, PermissionConstraint, Caveat, CaveatSpecificationConstraint } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { CronjobSpecification } from '@metamask/snaps-utils';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+import type { Json, NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.Cronjob;
+export declare const cronjobEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.Cronjob;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: any) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+    }>;
+}>;
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionsController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */
+export declare function getCronjobCaveatMapper(value: Json): Pick<PermissionConstraint, 'caveats'>;
+/**
+ * Getter function to get the cronjobs from a permission.
+ *
+ * This does basic validation of the caveat, but does not validate the type or
+ * value of the namespaces object itself, as this is handled by the
+ * `PermissionsController` when the permission is requested.
+ *
+ * @param permission - The permission to get the keyring namespaces from.
+ * @returns The cronjobs, or `null` if the permission does not have a
+ * cronjob caveat.
+ */
+export declare function getCronjobCaveatJobs(permission?: PermissionConstraint): CronjobSpecification[] | null;
+/**
+ * Validate the cronjob specification values associated with a caveat.
+ * This validates that the value is a non-empty array with valid
+ * cronjob expression and request object.
+ *
+ * @param caveat - The caveat to validate.
+ * @throws If the value is invalid.
+ */
+export declare function validateCronjobCaveat(caveat: Caveat<string, any>): void;
+/**
+ * Caveat specification for the Cronjob.
+ */
+export declare const cronjobCaveatSpecifications: Record<SnapCaveatType.SnapCronjob, CaveatSpecificationConstraint>;
+export {};

package/dist/types/endowments/enum.d.ts

@@ -0,0 +1,13 @@
+export declare enum SnapEndowments {
+    NetworkAccess = "endowment:network-access",
+    SignatureInsight = "endowment:signature-insight",
+    TransactionInsight = "endowment:transaction-insight",
+    Cronjob = "endowment:cronjob",
+    EthereumProvider = "endowment:ethereum-provider",
+    Rpc = "endowment:rpc",
+    WebAssemblyAccess = "endowment:webassembly",
+    NameLookup = "endowment:name-lookup",
+    LifecycleHooks = "endowment:lifecycle-hooks",
+    Keyring = "endowment:keyring",
+    HomePage = "endowment:page-home"
+}

package/dist/types/endowments/ethereum-provider.d.ts

@@ -0,0 +1,14 @@
+import type { PermissionSpecificationBuilder } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.EthereumProvider;
+export declare const ethereumProviderEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.EthereumProvider;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: any) => ['ethereum'];
+        allowedCaveats: null;
+    }>;
+}>;
+export {};

package/dist/types/endowments/home-page.d.ts

@@ -0,0 +1,15 @@
+import type { PermissionSpecificationBuilder, EndowmentGetterParams } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.HomePage;
+export declare const homePageEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.HomePage;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: EndowmentGetterParams) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+    }>;
+}>;
+export {};

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

@@ -0,0 +1,131 @@
+import type { PermissionConstraint } from '@metamask/permission-controller';
+import { HandlerType } from '@metamask/snaps-utils';
+import type { Json } from '@metamask/utils';
+export declare const endowmentPermissionBuilders: {
+    readonly "endowment:network-access": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.NetworkAccess;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.NetworkAccess;
+            endowmentGetter: (_options?: any) => ["fetch", "Request", "Headers", "Response"];
+            allowedCaveats: null;
+        }>;
+    }>;
+    readonly "endowment:transaction-insight": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.TransactionInsight;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.TransactionInsight;
+            endowmentGetter: (_options?: import("@metamask/permission-controller").EndowmentGetterParams | undefined) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+        }>;
+    }>;
+    readonly "endowment:cronjob": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.Cronjob;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.Cronjob;
+            endowmentGetter: (_options?: any) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+    }>;
+    readonly "endowment:ethereum-provider": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.EthereumProvider;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.EthereumProvider;
+            endowmentGetter: (_options?: any) => ["ethereum"];
+            allowedCaveats: null;
+        }>;
+    }>;
+    readonly "endowment:rpc": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.Rpc;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, {}, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.Rpc;
+            endowmentGetter: (_options?: any) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+            subjectTypes: readonly import("@metamask/permission-controller").SubjectType[];
+        }>;
+    }>;
+    readonly "endowment:webassembly": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.WebAssemblyAccess;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.WebAssemblyAccess;
+            endowmentGetter: (_options?: any) => ["WebAssembly"];
+            allowedCaveats: null;
+        }>;
+    }>;
+    readonly "endowment:name-lookup": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.NameLookup;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.NameLookup;
+            endowmentGetter: (_options?: import("@metamask/permission-controller").EndowmentGetterParams | undefined) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+        }>;
+    }>;
+    readonly "endowment:lifecycle-hooks": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.LifecycleHooks;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.LifecycleHooks;
+            endowmentGetter: (_options?: import("@metamask/permission-controller").EndowmentGetterParams | undefined) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+    }>;
+    readonly "endowment:keyring": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.Keyring;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.Keyring;
+            endowmentGetter: (_options?: import("@metamask/permission-controller").EndowmentGetterParams | undefined) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+            subjectTypes: readonly import("@metamask/permission-controller").SubjectType[];
+        }>;
+    }>;
+    readonly "endowment:page-home": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.HomePage;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.HomePage;
+            endowmentGetter: (_options?: import("@metamask/permission-controller").EndowmentGetterParams | undefined) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+        }>;
+    }>;
+    readonly "endowment:signature-insight": Readonly<{
+        readonly targetName: import("./enum").SnapEndowments.SignatureInsight;
+        readonly specificationBuilder: import("@metamask/permission-controller").PermissionSpecificationBuilder<import("@metamask/permission-controller").PermissionType.Endowment, any, {
+            permissionType: import("@metamask/permission-controller").PermissionType.Endowment;
+            targetName: import("./enum").SnapEndowments.SignatureInsight;
+            endowmentGetter: (_options?: import("@metamask/permission-controller").EndowmentGetterParams | undefined) => undefined;
+            allowedCaveats: readonly [string, ...string[]] | null;
+            validator: import("@metamask/permission-controller").PermissionValidatorConstraint;
+        }>;
+    }>;
+};
+export declare const endowmentCaveatSpecifications: {
+    maxRequestTime: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+    signatureOrigin: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+    keyringOrigin: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+    chainIds: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+    lookupMatchers: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+    rpcOrigin: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+    transactionOrigin: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+    snapCronjob: import("@metamask/permission-controller").CaveatSpecificationConstraint;
+};
+export declare const endowmentCaveatMappers: Record<string, (value: Json) => Pick<PermissionConstraint, 'caveats'>>;
+export declare const handlerEndowments: Record<HandlerType, string | null>;
+export * from './enum';
+export { getRpcCaveatOrigins } from './rpc';
+export { getSignatureOriginCaveat } from './signature-insight';
+export { getTransactionOriginCaveat } from './transaction-insight';
+export { getChainIdsCaveat, getLookupMatchersCaveat } from './name-lookup';
+export { getKeyringCaveatOrigins } from './keyring';
+export { getMaxRequestTimeCaveat } from './caveats';
+export { getCronjobCaveatJobs } from './cronjob';

package/dist/types/endowments/keyring.d.ts

@@ -0,0 +1,39 @@
+import type { CaveatSpecificationConstraint, EndowmentGetterParams, PermissionConstraint, PermissionSpecificationBuilder, PermissionValidatorConstraint } from '@metamask/permission-controller';
+import { PermissionType, SubjectType } from '@metamask/permission-controller';
+import type { KeyringOrigins } from '@metamask/snaps-utils';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+import type { Json, NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.Keyring;
+export declare const keyringEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.Keyring;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: EndowmentGetterParams) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+        subjectTypes: readonly SubjectType[];
+    }>;
+}>;
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionsController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */
+export declare function getKeyringCaveatMapper(value: Json): Pick<PermissionConstraint, 'caveats'>;
+/**
+ * Getter function to get the {@link KeyringOrigins} caveat value from a
+ * permission.
+ *
+ * @param permission - The permission to get the caveat value from.
+ * @returns The caveat value.
+ * @throws If the permission does not have a valid {@link KeyringOrigins}
+ * caveat.
+ */
+export declare function getKeyringCaveatOrigins(permission?: PermissionConstraint): KeyringOrigins | null;
+export declare const keyringCaveatSpecifications: Record<SnapCaveatType.KeyringOrigin, CaveatSpecificationConstraint>;
+export {};

package/dist/types/endowments/lifecycle-hooks.d.ts

@@ -0,0 +1,15 @@
+import type { PermissionSpecificationBuilder, EndowmentGetterParams } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import type { NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.LifecycleHooks;
+export declare const lifecycleHooksEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.LifecycleHooks;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: EndowmentGetterParams) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+    }>;
+}>;
+export {};

package/dist/types/endowments/name-lookup.d.ts

@@ -0,0 +1,49 @@
+import type { EndowmentGetterParams, PermissionSpecificationBuilder, PermissionValidatorConstraint, CaveatSpecificationConstraint, PermissionConstraint } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+import type { Json, NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.NameLookup;
+export declare const nameLookupEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.NameLookup;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: EndowmentGetterParams) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+    }>;
+}>;
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionsController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */
+export declare function getNameLookupCaveatMapper(value: Json): Pick<PermissionConstraint, 'caveats'>;
+/**
+ * Getter function to get the chainIds caveat from a permission.
+ *
+ * This does basic validation of the caveat, but does not validate the type or
+ * value of the namespaces object itself, as this is handled by the
+ * `PermissionsController` when the permission is requested.
+ *
+ * @param permission - The permission to get the `chainIds` caveat from.
+ * @returns An array of `chainIds` that the snap supports.
+ */
+export declare function getChainIdsCaveat(permission?: PermissionConstraint): string[] | null;
+/**
+ * Getter function to get the matchers caveat from a permission.
+ *
+ * This does basic validation of the caveat, but does not validate the type or
+ * value of the namespaces object itself, as this is handled by the
+ * `PermissionsController` when the permission is requested.
+ *
+ * @param permission - The permission to get the `matchers` caveat from.
+ * @returns A `matchers` object that defines the input that the snap supports.
+ */
+export declare function getLookupMatchersCaveat(permission?: PermissionConstraint): Record<string, string[]> | null;
+export declare const nameLookupCaveatSpecifications: Record<SnapCaveatType.ChainIds | SnapCaveatType.LookupMatchers, CaveatSpecificationConstraint>;
+export {};

package/dist/types/endowments/network-access.d.ts

@@ -0,0 +1,14 @@
+import type { PermissionSpecificationBuilder } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.NetworkAccess;
+export declare const networkAccessEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.NetworkAccess;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: any) => ['fetch', 'Request', 'Headers', 'Response'];
+        allowedCaveats: null;
+    }>;
+}>;
+export {};

package/dist/types/endowments/rpc.d.ts

@@ -0,0 +1,38 @@
+import type { CaveatSpecificationConstraint, PermissionConstraint, PermissionSpecificationBuilder, PermissionValidatorConstraint } from '@metamask/permission-controller';
+import { PermissionType, SubjectType } from '@metamask/permission-controller';
+import type { RpcOrigins } from '@metamask/snaps-utils';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+import type { Json, NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const targetName = SnapEndowments.Rpc;
+declare type RpcSpecificationBuilderOptions = {};
+export declare const rpcEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.Rpc;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, RpcSpecificationBuilderOptions, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof targetName;
+        endowmentGetter: (_options?: any) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+        subjectTypes: readonly SubjectType[];
+    }>;
+}>;
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionsController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */
+export declare function getRpcCaveatMapper(value: Json): Pick<PermissionConstraint, 'caveats'>;
+/**
+ * Getter function to get the {@link RpcOrigins} caveat value from a permission.
+ *
+ * @param permission - The permission to get the caveat value from.
+ * @returns The caveat value.
+ * @throws If the permission does not have a valid {@link RpcOrigins} caveat.
+ */
+export declare function getRpcCaveatOrigins(permission?: PermissionConstraint): RpcOrigins | null;
+export declare const rpcCaveatSpecifications: Record<SnapCaveatType.RpcOrigin, CaveatSpecificationConstraint>;
+export {};

package/dist/types/endowments/signature-insight.d.ts

@@ -0,0 +1,39 @@
+import type { PermissionSpecificationBuilder, EndowmentGetterParams, PermissionValidatorConstraint, PermissionConstraint, CaveatSpecificationConstraint } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+import type { Json, NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.SignatureInsight;
+export declare const signatureInsightEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.SignatureInsight;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: EndowmentGetterParams) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+    }>;
+}>;
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */
+export declare function getSignatureInsightCaveatMapper(value: Json): Pick<PermissionConstraint, 'caveats'>;
+/**
+ * Getter function to get the signature origin caveat from a permission.
+ *
+ * This does basic validation of the caveat, but does not validate the type or
+ * value of the namespaces object itself, as this is handled by the
+ * `PermissionsController` when the permission is requested.
+ *
+ * @param permission - The permission to get the signature origin caveat from.
+ * @returns The signature origin, or `null` if the permission does not have a
+ * signature origin caveat.
+ */
+export declare function getSignatureOriginCaveat(permission?: PermissionConstraint): boolean | null;
+export declare const signatureInsightCaveatSpecifications: Record<SnapCaveatType.SignatureOrigin, CaveatSpecificationConstraint>;
+export {};

package/dist/types/endowments/transaction-insight.d.ts

@@ -0,0 +1,39 @@
+import type { PermissionSpecificationBuilder, EndowmentGetterParams, PermissionValidatorConstraint, PermissionConstraint, CaveatSpecificationConstraint } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import { SnapCaveatType } from '@metamask/snaps-utils';
+import type { Json, NonEmptyArray } from '@metamask/utils';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.TransactionInsight;
+export declare const transactionInsightEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.TransactionInsight;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: EndowmentGetterParams) => undefined;
+        allowedCaveats: Readonly<NonEmptyArray<string>> | null;
+        validator: PermissionValidatorConstraint;
+    }>;
+}>;
+/**
+ * Map a raw value from the `initialPermissions` to a caveat specification.
+ * Note that this function does not do any validation, that's handled by the
+ * PermissionsController when the permission is requested.
+ *
+ * @param value - The raw value from the `initialPermissions`.
+ * @returns The caveat specification.
+ */
+export declare function getTransactionInsightCaveatMapper(value: Json): Pick<PermissionConstraint, 'caveats'>;
+/**
+ * Getter function to get the transaction origin caveat from a permission.
+ *
+ * This does basic validation of the caveat, but does not validate the type or
+ * value of the namespaces object itself, as this is handled by the
+ * `PermissionsController` when the permission is requested.
+ *
+ * @param permission - The permission to get the transaction origin caveat from.
+ * @returns The transaction origin, or `null` if the permission does not have a
+ * transaction origin caveat.
+ */
+export declare function getTransactionOriginCaveat(permission?: PermissionConstraint): boolean | null;
+export declare const transactionInsightCaveatSpecifications: Record<SnapCaveatType.TransactionOrigin, CaveatSpecificationConstraint>;
+export {};

package/dist/types/endowments/web-assembly.d.ts

@@ -0,0 +1,14 @@
+import type { PermissionSpecificationBuilder } from '@metamask/permission-controller';
+import { PermissionType } from '@metamask/permission-controller';
+import { SnapEndowments } from './enum';
+declare const permissionName = SnapEndowments.WebAssemblyAccess;
+export declare const webAssemblyEndowmentBuilder: Readonly<{
+    readonly targetName: SnapEndowments.WebAssemblyAccess;
+    readonly specificationBuilder: PermissionSpecificationBuilder<PermissionType.Endowment, any, {
+        permissionType: PermissionType.Endowment;
+        targetName: typeof permissionName;
+        endowmentGetter: (_options?: any) => ['WebAssembly'];
+        allowedCaveats: null;
+    }>;
+}>;
+export {};

package/dist/types/index.d.ts

@@ -1,5 +1,7 @@
-export type { PermittedRpcMethodHooks } from './permitted';
 export { handlers as permittedMethods, createSnapsMethodMiddleware, } from './permitted';
-export * from './restricted';
+export type { PermittedRpcMethodHooks } from './permitted';
 export { SnapCaveatType } from '@metamask/snaps-utils';
 export { selectHooks } from './utils';
+export * from './endowments';
+export * from './permissions';
+export * from './restricted';

package/dist/types/permissions.d.ts

@@ -0,0 +1,16 @@
+import type { PermissionConstraint, PermissionSpecificationConstraint } from '@metamask/permission-controller';
+import type { SnapPermissions } from '@metamask/snaps-utils';
+/**
+ * Map initial permissions as defined in a Snap manifest to something that can
+ * be processed by the PermissionsController. Each caveat mapping function
+ * should return a valid permission caveat value.
+ *
+ * This function does not validate the caveat values, since that is done by
+ * the PermissionsController itself, upon requesting the permissions.
+ *
+ * @param initialPermissions - The initial permissions to process.
+ * @returns The processed permissions.
+ */
+export declare function processSnapPermissions(initialPermissions: SnapPermissions): Record<string, Pick<PermissionConstraint, 'caveats'>>;
+export declare const buildSnapEndowmentSpecifications: (excludedEndowments: string[]) => Record<string, PermissionSpecificationConstraint>;
+export declare const buildSnapRestrictedMethodSpecifications: (excludedPermissions: string[], hooks: Record<string, unknown>) => Record<string, PermissionSpecificationConstraint>;