@metamask/snaps-rpc-methods 11.0.0 → 11.1.1

package/dist/restricted/notify.mjs

@@ -1,13 +1,102 @@
-import {
-  getImplementation,
-  getValidatedParams,
-  notifyBuilder,
-  specificationBuilder
-} from "../chunk-JWDQUKKU.mjs";
-export {
-  getImplementation,
-  getValidatedParams,
-  notifyBuilder,
-  specificationBuilder
+import { PermissionType, SubjectType } from "@metamask/permission-controller";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { NotificationType } from "@metamask/snaps-sdk";
+import { validateTextLinks } from "@metamask/snaps-utils";
+import { isObject } from "@metamask/utils";
+const methodName = 'snap_notify';
+/**
+ * The specification builder for the `snap_notify` permission.
+ * `snap_notify` allows snaps to send multiple types of notifications to its users.
+ *
+ * @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_notify` permission.
+ */
+export const specificationBuilder = ({ allowedCaveats = null, methodHooks }) => {
+    return {
+        permissionType: PermissionType.RestrictedMethod,
+        targetName: methodName,
+        allowedCaveats,
+        methodImplementation: getImplementation(methodHooks),
+        subjectTypes: [SubjectType.Snap],
+    };
 };
+const methodHooks = {
+    showNativeNotification: true,
+    showInAppNotification: true,
+    isOnPhishingList: true,
+    maybeUpdatePhishingList: true,
+};
+export const notifyBuilder = Object.freeze({
+    targetName: methodName,
+    specificationBuilder,
+    methodHooks,
+});
+/**
+ * Builds the method implementation for `snap_notify`.
+ *
+ * @param hooks - The RPC method hooks.
+ * @param hooks.showNativeNotification - A function that shows a native browser notification.
+ * @param hooks.showInAppNotification - A function that shows a notification in the MetaMask UI.
+ * @param hooks.isOnPhishingList - A function that checks for links against the phishing list.
+ * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.
+ * @returns The method implementation which returns `null` on success.
+ * @throws If the params are invalid.
+ */
+export function getImplementation({ showNativeNotification, showInAppNotification, isOnPhishingList, maybeUpdatePhishingList, }) {
+    return async function implementation(args) {
+        const { params, context: { origin }, } = args;
+        const validatedParams = getValidatedParams(params);
+        await maybeUpdatePhishingList();
+        validateTextLinks(validatedParams.message, isOnPhishingList);
+        switch (validatedParams.type) {
+            case NotificationType.Native:
+                return await showNativeNotification(origin, validatedParams);
+            case NotificationType.InApp:
+                return await showInAppNotification(origin, validatedParams);
+            default:
+                throw rpcErrors.invalidParams({
+                    message: 'Must specify a valid notification "type".',
+                });
+        }
+    };
+}
+/**
+ * Validates the notify method `params` and returns them cast to the correct
+ * type. Throws if validation fails.
+ *
+ * @param params - The unvalidated params object from the method request.
+ * @returns The validated method parameter object.
+ */
+export function getValidatedParams(params) {
+    if (!isObject(params)) {
+        throw rpcErrors.invalidParams({
+            message: 'Expected params to be a single object.',
+        });
+    }
+    const { type, message } = params;
+    if (!type ||
+        typeof type !== 'string' ||
+        !Object.values(NotificationType).includes(type)) {
+        throw rpcErrors.invalidParams({
+            message: 'Must specify a valid notification "type".',
+        });
+    }
+    const isNotString = !message || typeof message !== 'string';
+    // Set to the max message length on a Mac notification for now.
+    if (type === NotificationType.Native &&
+        (isNotString || message.length >= 50)) {
+        throw rpcErrors.invalidParams({
+            message: 'Must specify a non-empty string "message" less than 50 characters long.',
+        });
+    }
+    if (type === NotificationType.InApp &&
+        (isNotString || message.length >= 500)) {
+        throw rpcErrors.invalidParams({
+            message: 'Must specify a non-empty string "message" less than 500 characters long.',
+        });
+    }
+    return params;
+}
 //# sourceMappingURL=notify.mjs.map

package/dist/restricted/notify.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"notify.mjs","sourceRoot":"","sources":["../../src/restricted/notify.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  PermissionSpecificationBuilder,\n  RestrictedMethodOptions,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\nimport { rpcErrors } from '@metamask/rpc-errors';\nimport { NotificationType } from '@metamask/snaps-sdk';\nimport type {\n  NotifyParams,\n  NotifyResult,\n  EnumToUnion,\n} from '@metamask/snaps-sdk';\nimport { validateTextLinks } from '@metamask/snaps-utils';\nimport type { NonEmptyArray } from '@metamask/utils';\nimport { isObject } from '@metamask/utils';\n\nimport { type MethodHooksObject } from '../utils';\n\nconst methodName = 'snap_notify';\n\nexport type NotificationArgs = {\n  /**\n   * Enum type to determine notification type.\n   */\n  type: EnumToUnion<NotificationType>;\n\n  /**\n   * A message to show on the notification.\n   */\n  message: string;\n};\n\nexport type NotifyMethodHooks = {\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showNativeNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  /**\n   * @param snapId - The ID of the Snap that created the notification.\n   * @param args - The notification arguments.\n   */\n  showInAppNotification: (\n    snapId: string,\n    args: NotificationArgs,\n  ) => Promise<null>;\n\n  isOnPhishingList: (url: string) => boolean;\n\n  maybeUpdatePhishingList: () => Promise<void>;\n};\n\ntype SpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: NotifyMethodHooks;\n};\n\ntype Specification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_notify` permission.\n * `snap_notify` allows snaps to send multiple types of notifications to its users.\n *\n * @param options - The specification builder options.\n * @param options.allowedCaveats - The optional allowed caveats for the permission.\n * @param options.methodHooks - The RPC method hooks needed by the method implementation.\n * @returns The specification for the `snap_notify` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  SpecificationBuilderOptions,\n  Specification\n> = ({ allowedCaveats = null, methodHooks }: SpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<NotifyMethodHooks> = {\n  showNativeNotification: true,\n  showInAppNotification: true,\n  isOnPhishingList: true,\n  maybeUpdatePhishingList: true,\n};\n\nexport const notifyBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\n/**\n * Builds the method implementation for `snap_notify`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.showNativeNotification - A function that shows a native browser notification.\n * @param hooks.showInAppNotification - A function that shows a notification in the MetaMask UI.\n * @param hooks.isOnPhishingList - A function that checks for links against the phishing list.\n * @param hooks.maybeUpdatePhishingList - A function that updates the phishing list if needed.\n * @returns The method implementation which returns `null` on success.\n * @throws If the params are invalid.\n */\nexport function getImplementation({\n  showNativeNotification,\n  showInAppNotification,\n  isOnPhishingList,\n  maybeUpdatePhishingList,\n}: NotifyMethodHooks) {\n  return async function implementation(\n    args: RestrictedMethodOptions<NotifyParams>,\n  ): Promise<NotifyResult> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    const validatedParams = getValidatedParams(params);\n\n    await maybeUpdatePhishingList();\n\n    validateTextLinks(validatedParams.message, isOnPhishingList);\n\n    switch (validatedParams.type) {\n      case NotificationType.Native:\n        return await showNativeNotification(origin, validatedParams);\n      case NotificationType.InApp:\n        return await showInAppNotification(origin, validatedParams);\n      default:\n        throw rpcErrors.invalidParams({\n          message: 'Must specify a valid notification \"type\".',\n        });\n    }\n  };\n}\n\n/**\n * Validates the notify method `params` and returns them cast to the correct\n * type. Throws if validation fails.\n *\n * @param params - The unvalidated params object from the method request.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(params: unknown): NotifyParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { type, message } = params;\n\n  if (\n    !type ||\n    typeof type !== 'string' ||\n    !Object.values(NotificationType).includes(type as NotificationType)\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid notification \"type\".',\n    });\n  }\n\n  const isNotString = !message || typeof message !== 'string';\n  // Set to the max message length on a Mac notification for now.\n  if (\n    type === NotificationType.Native &&\n    (isNotString || message.length >= 50)\n  ) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Must specify a non-empty string \"message\" less than 50 characters long.',\n    });\n  }\n\n  if (\n    type === NotificationType.InApp &&\n    (isNotString || message.length >= 500)\n  ) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Must specify a non-empty string \"message\" less than 500 characters long.',\n    });\n  }\n\n  return params as NotificationArgs;\n}\n"]}

package/dist/utils.cjs

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNode = exports.getPathPrefix = exports.deriveEntropy = exports.selectHooks = void 0;
+const key_tree_1 = require("@metamask/key-tree");
+const utils_1 = require("@metamask/utils");
+const sha3_1 = require("@noble/hashes/sha3");
+const HARDENED_VALUE = 0x80000000;
+/**
+ * Returns the subset of the specified `hooks` that are included in the
+ * `hookNames` object. This is a Principle of Least Authority (POLA) measure
+ * to ensure that each RPC method implementation only has access to the
+ * API "hooks" it needs to do its job.
+ *
+ * @param hooks - The hooks to select from.
+ * @param hookNames - The names of the hooks to select.
+ * @returns The selected hooks.
+ * @template Hooks - The hooks to select from.
+ * @template HookName - The names of the hooks to select.
+ */
+function selectHooks(hooks, hookNames) {
+    if (hookNames) {
+        return Object.keys(hookNames).reduce((hookSubset, _hookName) => {
+            const hookName = _hookName;
+            hookSubset[hookName] = hooks[hookName];
+            return hookSubset;
+        }, {});
+    }
+    return undefined;
+}
+exports.selectHooks = selectHooks;
+/**
+ * Get a BIP-32 derivation path array from a hash, which is compatible with
+ * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.
+ *
+ * @param hash - The hash to derive indices from.
+ * @returns The derived indices as a {@link HardenedBIP32Node} array.
+ */
+function getDerivationPathArray(hash) {
+    const array = [];
+    const view = (0, utils_1.createDataView)(hash);
+    for (let index = 0; index < 8; index++) {
+        const uint32 = view.getUint32(index * 4);
+        // This is essentially `index | 0x80000000`. Because JavaScript numbers are
+        // signed, we use the bitwise unsigned right shift operator to ensure that
+        // the result is a positive number.
+        // eslint-disable-next-line no-bitwise
+        const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;
+        array.push(`bip32:${pathIndex - HARDENED_VALUE}'`);
+    }
+    return array;
+}
+/**
+ * Derive entropy from the given mnemonic phrase and salt.
+ *
+ * This is based on the reference implementation of
+ * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).
+ *
+ * @param options - The options for entropy derivation.
+ * @param options.input - The input value to derive entropy from.
+ * @param options.salt - An optional salt to use when deriving entropy.
+ * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy
+ * derivation.
+ * @param options.magic - A hardened BIP-32 index, which is used to derive the
+ * root key from the mnemonic phrase.
+ * @returns The derived entropy.
+ */
+async function deriveEntropy({ input, salt = '', mnemonicPhrase, magic, }) {
+    const inputBytes = (0, utils_1.stringToBytes)(input);
+    const saltBytes = (0, utils_1.stringToBytes)(salt);
+    // Get the derivation path from the snap ID.
+    const hash = (0, sha3_1.keccak_256)((0, utils_1.concatBytes)([inputBytes, (0, sha3_1.keccak_256)(saltBytes)]));
+    const computedDerivationPath = getDerivationPathArray(hash);
+    // Derive the private key using BIP-32.
+    const { privateKey } = await key_tree_1.SLIP10Node.fromDerivationPath({
+        derivationPath: [
+            mnemonicPhrase,
+            `bip32:${magic}`,
+            ...computedDerivationPath,
+        ],
+        curve: 'secp256k1',
+    });
+    // This should never happen, but this keeps TypeScript happy.
+    (0, utils_1.assert)(privateKey, 'Failed to derive the entropy.');
+    return (0, utils_1.add0x)(privateKey);
+}
+exports.deriveEntropy = deriveEntropy;
+/**
+ * Get the path prefix to use for key derivation in `key-tree`. This assumes the
+ * following:
+ *
+ * - The Secp256k1 curve always uses the BIP-32 specification.
+ * - The Ed25519 curve always uses the SLIP-10 specification.
+ * - The BIP-32-Ed25519 curve always uses the CIP-3 specification.
+ *
+ * While this does not matter in most situations (no known case at the time of
+ * writing), `key-tree` requires a specific specification to be used.
+ *
+ * @param curve - The curve to get the path prefix for. The curve is NOT
+ * validated by this function.
+ * @returns The path prefix, i.e., `bip32` or `slip10`.
+ */
+function getPathPrefix(curve) {
+    switch (curve) {
+        case 'secp256k1':
+            return 'bip32';
+        case 'ed25519':
+            return 'slip10';
+        case 'ed25519Bip32':
+            return 'cip3';
+        default:
+            return (0, utils_1.assertExhaustive)(curve);
+    }
+}
+exports.getPathPrefix = getPathPrefix;
+/**
+ * Get a `key-tree`-compatible node.
+ *
+ * Note: This function assumes that all the parameters have been validated
+ * beforehand.
+ *
+ * @param options - The derivation options.
+ * @param options.curve - The curve to use for derivation.
+ * @param options.secretRecoveryPhrase - The secret recovery phrase to use for
+ * derivation.
+ * @param options.path - The derivation path to use as array, starting with an
+ * "m" as the first item.
+ * @returns The `key-tree` SLIP-10 node.
+ */
+async function getNode({ curve, secretRecoveryPhrase, path, }) {
+    const prefix = getPathPrefix(curve);
+    return await key_tree_1.SLIP10Node.fromDerivationPath({
+        curve,
+        derivationPath: [
+            secretRecoveryPhrase,
+            ...path.slice(1).map((index) => `${prefix}:${index}`),
+        ],
+    });
+}
+exports.getNode = getNode;
+//# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  HardenedBIP32Node,\n  BIP32Node,\n  SLIP10PathNode,\n  SupportedCurve,\n} from '@metamask/key-tree';\nimport { SLIP10Node } from '@metamask/key-tree';\nimport type { MagicValue } from '@metamask/snaps-utils';\nimport type { Hex } from '@metamask/utils';\nimport {\n  assertExhaustive,\n  add0x,\n  assert,\n  concatBytes,\n  createDataView,\n  stringToBytes,\n} from '@metamask/utils';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\n\nconst HARDENED_VALUE = 0x80000000;\n\n/**\n * Maps an interface with method hooks to an object, using the keys of the\n * interface, and `true` as value. This ensures that the `methodHooks` object\n * has the same values as the interface.\n */\nexport type MethodHooksObject<HooksType extends Record<string, unknown>> = {\n  [Key in keyof HooksType]: true;\n};\n\n/**\n * Returns the subset of the specified `hooks` that are included in the\n * `hookNames` object. This is a Principle of Least Authority (POLA) measure\n * to ensure that each RPC method implementation only has access to the\n * API \"hooks\" it needs to do its job.\n *\n * @param hooks - The hooks to select from.\n * @param hookNames - The names of the hooks to select.\n * @returns The selected hooks.\n * @template Hooks - The hooks to select from.\n * @template HookName - The names of the hooks to select.\n */\nexport function selectHooks<\n  Hooks extends Record<string, unknown>,\n  HookName extends keyof Hooks,\n>(\n  hooks: Hooks,\n  hookNames?: Record<HookName, boolean>,\n): Pick<Hooks, HookName> | undefined {\n  if (hookNames) {\n    return Object.keys(hookNames).reduce<Partial<Pick<Hooks, HookName>>>(\n      (hookSubset, _hookName) => {\n        const hookName = _hookName as HookName;\n        hookSubset[hookName] = hooks[hookName];\n        return hookSubset;\n      },\n      {},\n    ) as Pick<Hooks, HookName>;\n  }\n  return undefined;\n}\n\n/**\n * Get a BIP-32 derivation path array from a hash, which is compatible with\n * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.\n *\n * @param hash - The hash to derive indices from.\n * @returns The derived indices as a {@link HardenedBIP32Node} array.\n */\nfunction getDerivationPathArray(hash: Uint8Array): HardenedBIP32Node[] {\n  const array: HardenedBIP32Node[] = [];\n  const view = createDataView(hash);\n\n  for (let index = 0; index < 8; index++) {\n    const uint32 = view.getUint32(index * 4);\n\n    // This is essentially `index | 0x80000000`. Because JavaScript numbers are\n    // signed, we use the bitwise unsigned right shift operator to ensure that\n    // the result is a positive number.\n    // eslint-disable-next-line no-bitwise\n    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;\n    array.push(`bip32:${pathIndex - HARDENED_VALUE}'` as const);\n  }\n\n  return array;\n}\n\ntype DeriveEntropyOptions = {\n  /**\n   * The input value to derive entropy from.\n   */\n  input: string;\n\n  /**\n   * An optional salt to use when deriving entropy.\n   */\n  salt?: string;\n\n  /**\n   * The mnemonic phrase to use for entropy derivation.\n   */\n  mnemonicPhrase: Uint8Array;\n\n  /**\n   * A hardened BIP-32 index, which is used to derive the root key from the\n   * mnemonic phrase.\n   */\n  magic: MagicValue;\n};\n\n/**\n * Derive entropy from the given mnemonic phrase and salt.\n *\n * This is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param options - The options for entropy derivation.\n * @param options.input - The input value to derive entropy from.\n * @param options.salt - An optional salt to use when deriving entropy.\n * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy\n * derivation.\n * @param options.magic - A hardened BIP-32 index, which is used to derive the\n * root key from the mnemonic phrase.\n * @returns The derived entropy.\n */\nexport async function deriveEntropy({\n  input,\n  salt = '',\n  mnemonicPhrase,\n  magic,\n}: DeriveEntropyOptions): Promise<Hex> {\n  const inputBytes = stringToBytes(input);\n  const saltBytes = stringToBytes(salt);\n\n  // Get the derivation path from the snap ID.\n  const hash = keccak256(concatBytes([inputBytes, keccak256(saltBytes)]));\n  const computedDerivationPath = getDerivationPathArray(hash);\n\n  // Derive the private key using BIP-32.\n  const { privateKey } = await SLIP10Node.fromDerivationPath({\n    derivationPath: [\n      mnemonicPhrase,\n      `bip32:${magic}`,\n      ...computedDerivationPath,\n    ],\n    curve: 'secp256k1',\n  });\n\n  // This should never happen, but this keeps TypeScript happy.\n  assert(privateKey, 'Failed to derive the entropy.');\n\n  return add0x(privateKey);\n}\n\n/**\n * Get the path prefix to use for key derivation in `key-tree`. This assumes the\n * following:\n *\n * - The Secp256k1 curve always uses the BIP-32 specification.\n * - The Ed25519 curve always uses the SLIP-10 specification.\n * - The BIP-32-Ed25519 curve always uses the CIP-3 specification.\n *\n * While this does not matter in most situations (no known case at the time of\n * writing), `key-tree` requires a specific specification to be used.\n *\n * @param curve - The curve to get the path prefix for. The curve is NOT\n * validated by this function.\n * @returns The path prefix, i.e., `bip32` or `slip10`.\n */\nexport function getPathPrefix(\n  curve: SupportedCurve,\n): 'bip32' | 'slip10' | 'cip3' {\n  switch (curve) {\n    case 'secp256k1':\n      return 'bip32';\n    case 'ed25519':\n      return 'slip10';\n    case 'ed25519Bip32':\n      return 'cip3';\n    default:\n      return assertExhaustive(curve);\n  }\n}\n\ntype GetNodeArgs = {\n  curve: SupportedCurve;\n  secretRecoveryPhrase: Uint8Array;\n  path: string[];\n};\n\n/**\n * Get a `key-tree`-compatible node.\n *\n * Note: This function assumes that all the parameters have been validated\n * beforehand.\n *\n * @param options - The derivation options.\n * @param options.curve - The curve to use for derivation.\n * @param options.secretRecoveryPhrase - The secret recovery phrase to use for\n * derivation.\n * @param options.path - The derivation path to use as array, starting with an\n * \"m\" as the first item.\n * @returns The `key-tree` SLIP-10 node.\n */\nexport async function getNode({\n  curve,\n  secretRecoveryPhrase,\n  path,\n}: GetNodeArgs) {\n  const prefix = getPathPrefix(curve);\n\n  return await SLIP10Node.fromDerivationPath({\n    curve,\n    derivationPath: [\n      secretRecoveryPhrase,\n      ...(path.slice(1).map((index) => `${prefix}:${index}`) as\n        | BIP32Node[]\n        | SLIP10PathNode[]),\n    ],\n  });\n}\n"]}

package/dist/{types/utils.d.ts → utils.d.cts}

@@ -1,7 +1,7 @@
-import type { SupportedCurve } from '@metamask/key-tree';
-import { SLIP10Node } from '@metamask/key-tree';
-import type { MagicValue } from '@metamask/snaps-utils';
-import type { Hex } from '@metamask/utils';
+import type { SupportedCurve } from "@metamask/key-tree";
+import { SLIP10Node } from "@metamask/key-tree";
+import type { MagicValue } from "@metamask/snaps-utils";
+import type { Hex } from "@metamask/utils";
 /**
  * Maps an interface with method hooks to an object, using the keys of the
  * interface, and `true` as value. This ensures that the `methodHooks` object
@@ -91,6 +91,8 @@ type GetNodeArgs = {
  * derivation.
  * @param options.path - The derivation path to use as array, starting with an
  * "m" as the first item.
+ * @returns The `key-tree` SLIP-10 node.
  */
 export declare function getNode({ curve, secretRecoveryPhrase, path, }: GetNodeArgs): Promise<SLIP10Node>;
 export {};
+//# sourceMappingURL=utils.d.cts.map

package/dist/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EACf,2BAA2B;AAC5B,OAAO,EAAE,UAAU,EAAE,2BAA2B;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,8BAA8B;AACxD,OAAO,KAAK,EAAE,GAAG,EAAE,wBAAwB;AAa3C;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;KACxE,GAAG,IAAI,MAAM,SAAS,GAAG,IAAI;CAC/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,QAAQ,SAAS,MAAM,KAAK,EAE5B,KAAK,EAAE,KAAK,EACZ,SAAS,CAAC,EAAE,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,GACpC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,SAAS,CAYnC;AA2BD,KAAK,oBAAoB,GAAG;IAC1B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,cAAc,EAAE,UAAU,CAAC;IAE3B;;;OAGG;IACH,KAAK,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CAAC,EAClC,KAAK,EACL,IAAS,EACT,cAAc,EACd,KAAK,GACN,EAAE,oBAAoB,GAAG,OAAO,CAAC,GAAG,CAAC,CAsBrC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,GACpB,OAAO,GAAG,QAAQ,GAAG,MAAM,CAW7B;AAED,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,cAAc,CAAC;IACtB,oBAAoB,EAAE,UAAU,CAAC;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAAC,EAC5B,KAAK,EACL,oBAAoB,EACpB,IAAI,GACL,EAAE,WAAW,uBAYb"}

package/dist/utils.d.mts

@@ -0,0 +1,98 @@
+import type { SupportedCurve } from "@metamask/key-tree";
+import { SLIP10Node } from "@metamask/key-tree";
+import type { MagicValue } from "@metamask/snaps-utils";
+import type { Hex } from "@metamask/utils";
+/**
+ * Maps an interface with method hooks to an object, using the keys of the
+ * interface, and `true` as value. This ensures that the `methodHooks` object
+ * has the same values as the interface.
+ */
+export type MethodHooksObject<HooksType extends Record<string, unknown>> = {
+    [Key in keyof HooksType]: true;
+};
+/**
+ * Returns the subset of the specified `hooks` that are included in the
+ * `hookNames` object. This is a Principle of Least Authority (POLA) measure
+ * to ensure that each RPC method implementation only has access to the
+ * API "hooks" it needs to do its job.
+ *
+ * @param hooks - The hooks to select from.
+ * @param hookNames - The names of the hooks to select.
+ * @returns The selected hooks.
+ * @template Hooks - The hooks to select from.
+ * @template HookName - The names of the hooks to select.
+ */
+export declare function selectHooks<Hooks extends Record<string, unknown>, HookName extends keyof Hooks>(hooks: Hooks, hookNames?: Record<HookName, boolean>): Pick<Hooks, HookName> | undefined;
+type DeriveEntropyOptions = {
+    /**
+     * The input value to derive entropy from.
+     */
+    input: string;
+    /**
+     * An optional salt to use when deriving entropy.
+     */
+    salt?: string;
+    /**
+     * The mnemonic phrase to use for entropy derivation.
+     */
+    mnemonicPhrase: Uint8Array;
+    /**
+     * A hardened BIP-32 index, which is used to derive the root key from the
+     * mnemonic phrase.
+     */
+    magic: MagicValue;
+};
+/**
+ * Derive entropy from the given mnemonic phrase and salt.
+ *
+ * This is based on the reference implementation of
+ * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).
+ *
+ * @param options - The options for entropy derivation.
+ * @param options.input - The input value to derive entropy from.
+ * @param options.salt - An optional salt to use when deriving entropy.
+ * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy
+ * derivation.
+ * @param options.magic - A hardened BIP-32 index, which is used to derive the
+ * root key from the mnemonic phrase.
+ * @returns The derived entropy.
+ */
+export declare function deriveEntropy({ input, salt, mnemonicPhrase, magic, }: DeriveEntropyOptions): Promise<Hex>;
+/**
+ * Get the path prefix to use for key derivation in `key-tree`. This assumes the
+ * following:
+ *
+ * - The Secp256k1 curve always uses the BIP-32 specification.
+ * - The Ed25519 curve always uses the SLIP-10 specification.
+ * - The BIP-32-Ed25519 curve always uses the CIP-3 specification.
+ *
+ * While this does not matter in most situations (no known case at the time of
+ * writing), `key-tree` requires a specific specification to be used.
+ *
+ * @param curve - The curve to get the path prefix for. The curve is NOT
+ * validated by this function.
+ * @returns The path prefix, i.e., `bip32` or `slip10`.
+ */
+export declare function getPathPrefix(curve: SupportedCurve): 'bip32' | 'slip10' | 'cip3';
+type GetNodeArgs = {
+    curve: SupportedCurve;
+    secretRecoveryPhrase: Uint8Array;
+    path: string[];
+};
+/**
+ * Get a `key-tree`-compatible node.
+ *
+ * Note: This function assumes that all the parameters have been validated
+ * beforehand.
+ *
+ * @param options - The derivation options.
+ * @param options.curve - The curve to use for derivation.
+ * @param options.secretRecoveryPhrase - The secret recovery phrase to use for
+ * derivation.
+ * @param options.path - The derivation path to use as array, starting with an
+ * "m" as the first item.
+ * @returns The `key-tree` SLIP-10 node.
+ */
+export declare function getNode({ curve, secretRecoveryPhrase, path, }: GetNodeArgs): Promise<SLIP10Node>;
+export {};
+//# sourceMappingURL=utils.d.mts.map

package/dist/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EACf,2BAA2B;AAC5B,OAAO,EAAE,UAAU,EAAE,2BAA2B;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,8BAA8B;AACxD,OAAO,KAAK,EAAE,GAAG,EAAE,wBAAwB;AAa3C;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;KACxE,GAAG,IAAI,MAAM,SAAS,GAAG,IAAI;CAC/B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,QAAQ,SAAS,MAAM,KAAK,EAE5B,KAAK,EAAE,KAAK,EACZ,SAAS,CAAC,EAAE,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,GACpC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,SAAS,CAYnC;AA2BD,KAAK,oBAAoB,GAAG;IAC1B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,cAAc,EAAE,UAAU,CAAC;IAE3B;;;OAGG;IACH,KAAK,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,aAAa,CAAC,EAClC,KAAK,EACL,IAAS,EACT,cAAc,EACd,KAAK,GACN,EAAE,oBAAoB,GAAG,OAAO,CAAC,GAAG,CAAC,CAsBrC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,GACpB,OAAO,GAAG,QAAQ,GAAG,MAAM,CAW7B;AAED,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,cAAc,CAAC;IACtB,oBAAoB,EAAE,UAAU,CAAC;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAAC,EAC5B,KAAK,EACL,oBAAoB,EACpB,IAAI,GACL,EAAE,WAAW,uBAYb"}

package/dist/utils.mjs

@@ -1,13 +1,133 @@
-import {
-  deriveEntropy,
-  getNode,
-  getPathPrefix,
-  selectHooks
-} from "./chunk-W33UWNA2.mjs";
-export {
-  deriveEntropy,
-  getNode,
-  getPathPrefix,
-  selectHooks
-};
+import { SLIP10Node } from "@metamask/key-tree";
+import { assertExhaustive, add0x, assert, concatBytes, createDataView, stringToBytes } from "@metamask/utils";
+import { keccak_256 as keccak256 } from "@noble/hashes/sha3";
+const HARDENED_VALUE = 0x80000000;
+/**
+ * Returns the subset of the specified `hooks` that are included in the
+ * `hookNames` object. This is a Principle of Least Authority (POLA) measure
+ * to ensure that each RPC method implementation only has access to the
+ * API "hooks" it needs to do its job.
+ *
+ * @param hooks - The hooks to select from.
+ * @param hookNames - The names of the hooks to select.
+ * @returns The selected hooks.
+ * @template Hooks - The hooks to select from.
+ * @template HookName - The names of the hooks to select.
+ */
+export function selectHooks(hooks, hookNames) {
+    if (hookNames) {
+        return Object.keys(hookNames).reduce((hookSubset, _hookName) => {
+            const hookName = _hookName;
+            hookSubset[hookName] = hooks[hookName];
+            return hookSubset;
+        }, {});
+    }
+    return undefined;
+}
+/**
+ * Get a BIP-32 derivation path array from a hash, which is compatible with
+ * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.
+ *
+ * @param hash - The hash to derive indices from.
+ * @returns The derived indices as a {@link HardenedBIP32Node} array.
+ */
+function getDerivationPathArray(hash) {
+    const array = [];
+    const view = createDataView(hash);
+    for (let index = 0; index < 8; index++) {
+        const uint32 = view.getUint32(index * 4);
+        // This is essentially `index | 0x80000000`. Because JavaScript numbers are
+        // signed, we use the bitwise unsigned right shift operator to ensure that
+        // the result is a positive number.
+        // eslint-disable-next-line no-bitwise
+        const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;
+        array.push(`bip32:${pathIndex - HARDENED_VALUE}'`);
+    }
+    return array;
+}
+/**
+ * Derive entropy from the given mnemonic phrase and salt.
+ *
+ * This is based on the reference implementation of
+ * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).
+ *
+ * @param options - The options for entropy derivation.
+ * @param options.input - The input value to derive entropy from.
+ * @param options.salt - An optional salt to use when deriving entropy.
+ * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy
+ * derivation.
+ * @param options.magic - A hardened BIP-32 index, which is used to derive the
+ * root key from the mnemonic phrase.
+ * @returns The derived entropy.
+ */
+export async function deriveEntropy({ input, salt = '', mnemonicPhrase, magic, }) {
+    const inputBytes = stringToBytes(input);
+    const saltBytes = stringToBytes(salt);
+    // Get the derivation path from the snap ID.
+    const hash = keccak256(concatBytes([inputBytes, keccak256(saltBytes)]));
+    const computedDerivationPath = getDerivationPathArray(hash);
+    // Derive the private key using BIP-32.
+    const { privateKey } = await SLIP10Node.fromDerivationPath({
+        derivationPath: [
+            mnemonicPhrase,
+            `bip32:${magic}`,
+            ...computedDerivationPath,
+        ],
+        curve: 'secp256k1',
+    });
+    // This should never happen, but this keeps TypeScript happy.
+    assert(privateKey, 'Failed to derive the entropy.');
+    return add0x(privateKey);
+}
+/**
+ * Get the path prefix to use for key derivation in `key-tree`. This assumes the
+ * following:
+ *
+ * - The Secp256k1 curve always uses the BIP-32 specification.
+ * - The Ed25519 curve always uses the SLIP-10 specification.
+ * - The BIP-32-Ed25519 curve always uses the CIP-3 specification.
+ *
+ * While this does not matter in most situations (no known case at the time of
+ * writing), `key-tree` requires a specific specification to be used.
+ *
+ * @param curve - The curve to get the path prefix for. The curve is NOT
+ * validated by this function.
+ * @returns The path prefix, i.e., `bip32` or `slip10`.
+ */
+export function getPathPrefix(curve) {
+    switch (curve) {
+        case 'secp256k1':
+            return 'bip32';
+        case 'ed25519':
+            return 'slip10';
+        case 'ed25519Bip32':
+            return 'cip3';
+        default:
+            return assertExhaustive(curve);
+    }
+}
+/**
+ * Get a `key-tree`-compatible node.
+ *
+ * Note: This function assumes that all the parameters have been validated
+ * beforehand.
+ *
+ * @param options - The derivation options.
+ * @param options.curve - The curve to use for derivation.
+ * @param options.secretRecoveryPhrase - The secret recovery phrase to use for
+ * derivation.
+ * @param options.path - The derivation path to use as array, starting with an
+ * "m" as the first item.
+ * @returns The `key-tree` SLIP-10 node.
+ */
+export async function getNode({ curve, secretRecoveryPhrase, path, }) {
+    const prefix = getPathPrefix(curve);
+    return await SLIP10Node.fromDerivationPath({
+        curve,
+        derivationPath: [
+            secretRecoveryPhrase,
+            ...path.slice(1).map((index) => `${prefix}:${index}`),
+        ],
+    });
+}
 //# sourceMappingURL=utils.mjs.map

package/dist/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"utils.mjs","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  HardenedBIP32Node,\n  BIP32Node,\n  SLIP10PathNode,\n  SupportedCurve,\n} from '@metamask/key-tree';\nimport { SLIP10Node } from '@metamask/key-tree';\nimport type { MagicValue } from '@metamask/snaps-utils';\nimport type { Hex } from '@metamask/utils';\nimport {\n  assertExhaustive,\n  add0x,\n  assert,\n  concatBytes,\n  createDataView,\n  stringToBytes,\n} from '@metamask/utils';\nimport { keccak_256 as keccak256 } from '@noble/hashes/sha3';\n\nconst HARDENED_VALUE = 0x80000000;\n\n/**\n * Maps an interface with method hooks to an object, using the keys of the\n * interface, and `true` as value. This ensures that the `methodHooks` object\n * has the same values as the interface.\n */\nexport type MethodHooksObject<HooksType extends Record<string, unknown>> = {\n  [Key in keyof HooksType]: true;\n};\n\n/**\n * Returns the subset of the specified `hooks` that are included in the\n * `hookNames` object. This is a Principle of Least Authority (POLA) measure\n * to ensure that each RPC method implementation only has access to the\n * API \"hooks\" it needs to do its job.\n *\n * @param hooks - The hooks to select from.\n * @param hookNames - The names of the hooks to select.\n * @returns The selected hooks.\n * @template Hooks - The hooks to select from.\n * @template HookName - The names of the hooks to select.\n */\nexport function selectHooks<\n  Hooks extends Record<string, unknown>,\n  HookName extends keyof Hooks,\n>(\n  hooks: Hooks,\n  hookNames?: Record<HookName, boolean>,\n): Pick<Hooks, HookName> | undefined {\n  if (hookNames) {\n    return Object.keys(hookNames).reduce<Partial<Pick<Hooks, HookName>>>(\n      (hookSubset, _hookName) => {\n        const hookName = _hookName as HookName;\n        hookSubset[hookName] = hooks[hookName];\n        return hookSubset;\n      },\n      {},\n    ) as Pick<Hooks, HookName>;\n  }\n  return undefined;\n}\n\n/**\n * Get a BIP-32 derivation path array from a hash, which is compatible with\n * `@metamask/key-tree`. The hash is assumed to be 32 bytes long.\n *\n * @param hash - The hash to derive indices from.\n * @returns The derived indices as a {@link HardenedBIP32Node} array.\n */\nfunction getDerivationPathArray(hash: Uint8Array): HardenedBIP32Node[] {\n  const array: HardenedBIP32Node[] = [];\n  const view = createDataView(hash);\n\n  for (let index = 0; index < 8; index++) {\n    const uint32 = view.getUint32(index * 4);\n\n    // This is essentially `index | 0x80000000`. Because JavaScript numbers are\n    // signed, we use the bitwise unsigned right shift operator to ensure that\n    // the result is a positive number.\n    // eslint-disable-next-line no-bitwise\n    const pathIndex = (uint32 | HARDENED_VALUE) >>> 0;\n    array.push(`bip32:${pathIndex - HARDENED_VALUE}'` as const);\n  }\n\n  return array;\n}\n\ntype DeriveEntropyOptions = {\n  /**\n   * The input value to derive entropy from.\n   */\n  input: string;\n\n  /**\n   * An optional salt to use when deriving entropy.\n   */\n  salt?: string;\n\n  /**\n   * The mnemonic phrase to use for entropy derivation.\n   */\n  mnemonicPhrase: Uint8Array;\n\n  /**\n   * A hardened BIP-32 index, which is used to derive the root key from the\n   * mnemonic phrase.\n   */\n  magic: MagicValue;\n};\n\n/**\n * Derive entropy from the given mnemonic phrase and salt.\n *\n * This is based on the reference implementation of\n * [SIP-6](https://metamask.github.io/SIPs/SIPS/sip-6).\n *\n * @param options - The options for entropy derivation.\n * @param options.input - The input value to derive entropy from.\n * @param options.salt - An optional salt to use when deriving entropy.\n * @param options.mnemonicPhrase - The mnemonic phrase to use for entropy\n * derivation.\n * @param options.magic - A hardened BIP-32 index, which is used to derive the\n * root key from the mnemonic phrase.\n * @returns The derived entropy.\n */\nexport async function deriveEntropy({\n  input,\n  salt = '',\n  mnemonicPhrase,\n  magic,\n}: DeriveEntropyOptions): Promise<Hex> {\n  const inputBytes = stringToBytes(input);\n  const saltBytes = stringToBytes(salt);\n\n  // Get the derivation path from the snap ID.\n  const hash = keccak256(concatBytes([inputBytes, keccak256(saltBytes)]));\n  const computedDerivationPath = getDerivationPathArray(hash);\n\n  // Derive the private key using BIP-32.\n  const { privateKey } = await SLIP10Node.fromDerivationPath({\n    derivationPath: [\n      mnemonicPhrase,\n      `bip32:${magic}`,\n      ...computedDerivationPath,\n    ],\n    curve: 'secp256k1',\n  });\n\n  // This should never happen, but this keeps TypeScript happy.\n  assert(privateKey, 'Failed to derive the entropy.');\n\n  return add0x(privateKey);\n}\n\n/**\n * Get the path prefix to use for key derivation in `key-tree`. This assumes the\n * following:\n *\n * - The Secp256k1 curve always uses the BIP-32 specification.\n * - The Ed25519 curve always uses the SLIP-10 specification.\n * - The BIP-32-Ed25519 curve always uses the CIP-3 specification.\n *\n * While this does not matter in most situations (no known case at the time of\n * writing), `key-tree` requires a specific specification to be used.\n *\n * @param curve - The curve to get the path prefix for. The curve is NOT\n * validated by this function.\n * @returns The path prefix, i.e., `bip32` or `slip10`.\n */\nexport function getPathPrefix(\n  curve: SupportedCurve,\n): 'bip32' | 'slip10' | 'cip3' {\n  switch (curve) {\n    case 'secp256k1':\n      return 'bip32';\n    case 'ed25519':\n      return 'slip10';\n    case 'ed25519Bip32':\n      return 'cip3';\n    default:\n      return assertExhaustive(curve);\n  }\n}\n\ntype GetNodeArgs = {\n  curve: SupportedCurve;\n  secretRecoveryPhrase: Uint8Array;\n  path: string[];\n};\n\n/**\n * Get a `key-tree`-compatible node.\n *\n * Note: This function assumes that all the parameters have been validated\n * beforehand.\n *\n * @param options - The derivation options.\n * @param options.curve - The curve to use for derivation.\n * @param options.secretRecoveryPhrase - The secret recovery phrase to use for\n * derivation.\n * @param options.path - The derivation path to use as array, starting with an\n * \"m\" as the first item.\n * @returns The `key-tree` SLIP-10 node.\n */\nexport async function getNode({\n  curve,\n  secretRecoveryPhrase,\n  path,\n}: GetNodeArgs) {\n  const prefix = getPathPrefix(curve);\n\n  return await SLIP10Node.fromDerivationPath({\n    curve,\n    derivationPath: [\n      secretRecoveryPhrase,\n      ...(path.slice(1).map((index) => `${prefix}:${index}`) as\n        | BIP32Node[]\n        | SLIP10PathNode[]),\n    ],\n  });\n}\n"]}