@metamask/snaps-rpc-methods 3.2.1 → 4.0.0

package/dist/esm/restricted/manageState.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/restricted/manageState.ts"],"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 type { EnumToUnion } from '@metamask/snaps-utils';\nimport { STATE_ENCRYPTION_MAGIC_VALUE } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray, Hex } from '@metamask/utils';\nimport { isObject, getJsonSize, assert, isValidJson } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\n// The salt used for SIP-6-based entropy derivation.\nexport const STATE_ENCRYPTION_SALT = 'snap_manageState encryption';\n\nconst methodName = 'snap_manageState';\n\nexport type ManageStateMethodHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n\n  /**\n   * A function that clears the state of the requesting Snap.\n   */\n  clearSnapState: (snapId: string) => Promise<void>;\n\n  /**\n   * A function that gets the encrypted state of the requesting Snap.\n   *\n   * @returns The current state of the Snap.\n   */\n  getSnapState: (snapId: string) => Promise<string>;\n\n  /**\n   * A function that updates the state of the requesting Snap.\n   *\n   * @param newState - The new state of the Snap.\n   */\n  updateSnapState: (snapId: string, newState: string) => Promise<void>;\n\n  /**\n   * Encrypts data with a key. This is assumed to perform symmetric encryption.\n   *\n   * @param key - The key to use for encryption, in hexadecimal format.\n   * @param data - The JSON data to encrypt.\n   * @returns The ciphertext as a string. The format for this string is\n   * dependent on the implementation, but MUST be a string.\n   */\n  encrypt: (key: string, data: Json) => Promise<string>;\n\n  /**\n   * Decrypts data with a key. This is assumed to perform symmetric decryption.\n   *\n   * @param key - The key to use for decryption, in hexadecimal format.\n   * @param cipherText - The ciphertext to decrypt. The format for this string\n   * is dependent on the implementation, but MUST be a string.\n   * @returns The decrypted data as a JSON object.\n   */\n  decrypt: (key: Hex, cipherText: string) => Promise<unknown>;\n};\n\ntype ManageStateSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageStateMethodHooks;\n};\n\ntype ManageStateSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getManageStateImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageState` permission.\n * `snap_manageState` lets the Snap store and manage some of its state on\n * your device.\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_manageState` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageStateSpecificationBuilderOptions,\n  ManageStateSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageStateSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getManageStateImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<ManageStateMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n  clearSnapState: true,\n  getSnapState: true,\n  updateSnapState: true,\n  encrypt: true,\n  decrypt: true,\n};\n\nexport const manageStateBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport enum ManageStateOperation {\n  ClearState = 'clear',\n  GetState = 'get',\n  UpdateState = 'update',\n}\n\nexport type ManageStateArgs = {\n  operation: EnumToUnion<ManageStateOperation>;\n  newState?: Record<string, Json>;\n};\n\nexport const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)\n\ntype GetEncryptionKeyArgs = {\n  snapId: string;\n  mnemonicPhrase: Uint8Array;\n};\n\n/**\n * Get a deterministic encryption key to use for encrypting and decrypting the\n * state.\n *\n * This key should only be used for state encryption using `snap_manageState`.\n * To get other encryption keys, a different salt can be used.\n *\n * @param args - The encryption key args.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The state encryption key.\n */\nasync function getEncryptionKey({\n  mnemonicPhrase,\n  snapId,\n}: GetEncryptionKeyArgs) {\n  return await deriveEntropy({\n    mnemonicPhrase,\n    input: snapId,\n    salt: STATE_ENCRYPTION_SALT,\n    magic: STATE_ENCRYPTION_MAGIC_VALUE,\n  });\n}\n\ntype EncryptStateArgs = GetEncryptionKeyArgs & {\n  state: Json;\n  encryptFunction: ManageStateMethodHooks['encrypt'];\n};\n\n/**\n * Encrypt the state using a deterministic encryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to encrypt.\n * @param args.encryptFunction - The function to use for encrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function encryptState({\n  state,\n  encryptFunction,\n  ...keyArgs\n}: EncryptStateArgs) {\n  const encryptionKey = await getEncryptionKey(keyArgs);\n  return await encryptFunction(encryptionKey, state);\n}\n\ntype DecryptStateArgs = GetEncryptionKeyArgs & {\n  state: string;\n  decryptFunction: ManageStateMethodHooks['decrypt'];\n};\n\n/**\n * Decrypt the state using a deterministic decryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to decrypt.\n * @param args.decryptFunction - The function to use for decrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function decryptState({\n  state,\n  decryptFunction,\n  ...keyArgs\n}: DecryptStateArgs) {\n  try {\n    const encryptionKey = await getEncryptionKey(keyArgs);\n    const decryptedState = await decryptFunction(encryptionKey, state);\n\n    assert(isValidJson(decryptedState));\n\n    return decryptedState as Record<string, Json>;\n  } catch {\n    throw rpcErrors.internal({\n      message: 'Failed to decrypt snap state, the state must be corrupted.',\n    });\n  }\n}\n\n/**\n * Builds the method implementation for `snap_manageState`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.clearSnapState - A function that clears the state stored for a\n * snap.\n * @param hooks.getSnapState - A function that fetches the persisted decrypted\n * state for a snap.\n * @param hooks.updateSnapState - A function that updates the state stored for a\n * snap.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase\n * of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @param hooks.encrypt - A function that encrypts the given state.\n * @param hooks.decrypt - A function that decrypts the given state.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function getManageStateImplementation({\n  getMnemonic,\n  getUnlockPromise,\n  clearSnapState,\n  getSnapState,\n  updateSnapState,\n  encrypt,\n  decrypt,\n}: ManageStateMethodHooks) {\n  return async function manageState(\n    options: RestrictedMethodOptions<ManageStateArgs>,\n  ): Promise<null | Record<string, Json>> {\n    const {\n      params = {},\n      method,\n      context: { origin },\n    } = options;\n    const { operation, newState } = getValidatedParams(params, method);\n\n    await getUnlockPromise(true);\n    const mnemonicPhrase = await getMnemonic();\n\n    switch (operation) {\n      case ManageStateOperation.ClearState:\n        await clearSnapState(origin);\n        return null;\n\n      case ManageStateOperation.GetState: {\n        const state = await getSnapState(origin);\n        if (state === null) {\n          return state;\n        }\n        return await decryptState({\n          state,\n          decryptFunction: decrypt,\n          mnemonicPhrase,\n          snapId: origin,\n        });\n      }\n\n      case ManageStateOperation.UpdateState: {\n        assert(newState);\n\n        const encryptedState = await encryptState({\n          state: newState,\n          encryptFunction: encrypt,\n          mnemonicPhrase,\n          snapId: origin,\n        });\n\n        await updateSnapState(origin, encryptedState);\n        return null;\n      }\n\n      default:\n        throw rpcErrors.invalidParams(\n          `Invalid ${method} operation: \"${operation as string}\"`,\n        );\n    }\n  };\n}\n\n/**\n * Validates the manageState 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 * @param method - RPC method name used for debugging errors.\n * @param storageSizeLimit - Maximum allowed size (in bytes) of a new state object.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(\n  params: unknown,\n  method: string,\n  storageSizeLimit = STORAGE_SIZE_LIMIT,\n): ManageStateArgs {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { operation, newState } = params;\n\n  if (\n    !operation ||\n    typeof operation !== 'string' ||\n    !(Object.values(ManageStateOperation) as string[]).includes(operation)\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid manage state \"operation\".',\n    });\n  }\n\n  if (operation === ManageStateOperation.UpdateState) {\n    if (!isObject(newState)) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be a plain object.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    let size;\n    try {\n      // `getJsonSize` will throw if the state is not JSON serializable.\n      size = getJsonSize(newState);\n    } catch {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be JSON serializable.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    if (size > storageSizeLimit) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n  }\n\n  return params as ManageStateArgs;\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","STATE_ENCRYPTION_MAGIC_VALUE","isObject","getJsonSize","assert","isValidJson","deriveEntropy","STATE_ENCRYPTION_SALT","methodName","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getManageStateImplementation","subjectTypes","Snap","getMnemonic","getUnlockPromise","clearSnapState","getSnapState","updateSnapState","encrypt","decrypt","manageStateBuilder","Object","freeze","ManageStateOperation","ClearState","GetState","UpdateState","STORAGE_SIZE_LIMIT","getEncryptionKey","mnemonicPhrase","snapId","input","salt","magic","encryptState","state","encryptFunction","keyArgs","encryptionKey","decryptState","decryptFunction","decryptedState","internal","message","manageState","options","params","method","context","origin","operation","newState","getValidatedParams","encryptedState","invalidParams","storageSizeLimit","values","includes","data","receivedNewState","size"],"mappings":"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"}
+{"version":3,"sources":["../../../src/restricted/manageState.ts"],"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 type { ManageStateParams, ManageStateResult } from '@metamask/snaps-sdk';\nimport { ManageStateOperation } from '@metamask/snaps-sdk';\nimport { STATE_ENCRYPTION_MAGIC_VALUE, parseJson } from '@metamask/snaps-utils';\nimport type { Json, NonEmptyArray, Hex } from '@metamask/utils';\nimport { isObject, getJsonSize, assert, isValidJson } from '@metamask/utils';\n\nimport type { MethodHooksObject } from '../utils';\nimport { deriveEntropy } from '../utils';\n\n// The salt used for SIP-6-based entropy derivation.\nexport const STATE_ENCRYPTION_SALT = 'snap_manageState encryption';\n\nconst methodName = 'snap_manageState';\n\nexport type ManageStateMethodHooks = {\n  /**\n   * @returns The mnemonic of the user's primary keyring.\n   */\n  getMnemonic: () => Promise<Uint8Array>;\n\n  /**\n   * Waits for the extension to be unlocked.\n   *\n   * @returns A promise that resolves once the extension is unlocked.\n   */\n  getUnlockPromise: (shouldShowUnlockRequest: boolean) => Promise<void>;\n\n  /**\n   * A function that clears the state of the requesting Snap.\n   */\n  clearSnapState: (snapId: string, encrypted: boolean) => void;\n\n  /**\n   * A function that gets the encrypted state of the requesting Snap.\n   *\n   * @returns The current state of the Snap.\n   */\n  getSnapState: (snapId: string, encrypted: boolean) => string;\n\n  /**\n   * A function that updates the state of the requesting Snap.\n   *\n   * @param newState - The new state of the Snap.\n   */\n  updateSnapState: (\n    snapId: string,\n    newState: string,\n    encrypted: boolean,\n  ) => void;\n\n  /**\n   * Encrypts data with a key. This is assumed to perform symmetric encryption.\n   *\n   * @param key - The key to use for encryption, in hexadecimal format.\n   * @param data - The JSON data to encrypt.\n   * @returns The ciphertext as a string. The format for this string is\n   * dependent on the implementation, but MUST be a string.\n   */\n  encrypt: (key: string, data: Json) => Promise<string>;\n\n  /**\n   * Decrypts data with a key. This is assumed to perform symmetric decryption.\n   *\n   * @param key - The key to use for decryption, in hexadecimal format.\n   * @param cipherText - The ciphertext to decrypt. The format for this string\n   * is dependent on the implementation, but MUST be a string.\n   * @returns The decrypted data as a JSON object.\n   */\n  decrypt: (key: Hex, cipherText: string) => Promise<unknown>;\n};\n\ntype ManageStateSpecificationBuilderOptions = {\n  allowedCaveats?: Readonly<NonEmptyArray<string>> | null;\n  methodHooks: ManageStateMethodHooks;\n};\n\ntype ManageStateSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.RestrictedMethod;\n  targetName: typeof methodName;\n  methodImplementation: ReturnType<typeof getManageStateImplementation>;\n  allowedCaveats: Readonly<NonEmptyArray<string>> | null;\n}>;\n\n/**\n * The specification builder for the `snap_manageState` permission.\n * `snap_manageState` lets the Snap store and manage some of its state on\n * your device.\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_manageState` permission.\n */\nexport const specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.RestrictedMethod,\n  ManageStateSpecificationBuilderOptions,\n  ManageStateSpecification\n> = ({\n  allowedCaveats = null,\n  methodHooks,\n}: ManageStateSpecificationBuilderOptions) => {\n  return {\n    permissionType: PermissionType.RestrictedMethod,\n    targetName: methodName,\n    allowedCaveats,\n    methodImplementation: getManageStateImplementation(methodHooks),\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nconst methodHooks: MethodHooksObject<ManageStateMethodHooks> = {\n  getMnemonic: true,\n  getUnlockPromise: true,\n  clearSnapState: true,\n  getSnapState: true,\n  updateSnapState: true,\n  encrypt: true,\n  decrypt: true,\n};\n\nexport const manageStateBuilder = Object.freeze({\n  targetName: methodName,\n  specificationBuilder,\n  methodHooks,\n} as const);\n\nexport const STORAGE_SIZE_LIMIT = 104857600; // In bytes (100MB)\n\ntype GetEncryptionKeyArgs = {\n  snapId: string;\n  mnemonicPhrase: Uint8Array;\n};\n\n/**\n * Get a deterministic encryption key to use for encrypting and decrypting the\n * state.\n *\n * This key should only be used for state encryption using `snap_manageState`.\n * To get other encryption keys, a different salt can be used.\n *\n * @param args - The encryption key args.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The state encryption key.\n */\nasync function getEncryptionKey({\n  mnemonicPhrase,\n  snapId,\n}: GetEncryptionKeyArgs) {\n  return await deriveEntropy({\n    mnemonicPhrase,\n    input: snapId,\n    salt: STATE_ENCRYPTION_SALT,\n    magic: STATE_ENCRYPTION_MAGIC_VALUE,\n  });\n}\n\ntype EncryptStateArgs = GetEncryptionKeyArgs & {\n  state: Json;\n  encryptFunction: ManageStateMethodHooks['encrypt'];\n};\n\n/**\n * Encrypt the state using a deterministic encryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to encrypt.\n * @param args.encryptFunction - The function to use for encrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function encryptState({\n  state,\n  encryptFunction,\n  ...keyArgs\n}: EncryptStateArgs) {\n  const encryptionKey = await getEncryptionKey(keyArgs);\n  return await encryptFunction(encryptionKey, state);\n}\n\ntype DecryptStateArgs = GetEncryptionKeyArgs & {\n  state: string;\n  decryptFunction: ManageStateMethodHooks['decrypt'];\n};\n\n/**\n * Decrypt the state using a deterministic decryption algorithm, based on the\n * snap ID and mnemonic phrase.\n *\n * @param args - The encryption args.\n * @param args.state - The state to decrypt.\n * @param args.decryptFunction - The function to use for decrypting the state.\n * @param args.snapId - The ID of the snap to get the encryption key for.\n * @param args.mnemonicPhrase - The mnemonic phrase to derive the encryption key\n * from.\n * @returns The encrypted state.\n */\nasync function decryptState({\n  state,\n  decryptFunction,\n  ...keyArgs\n}: DecryptStateArgs) {\n  try {\n    const encryptionKey = await getEncryptionKey(keyArgs);\n    const decryptedState = await decryptFunction(encryptionKey, state);\n\n    assert(isValidJson(decryptedState));\n\n    return decryptedState as Record<string, Json>;\n  } catch {\n    throw rpcErrors.internal({\n      message: 'Failed to decrypt snap state, the state must be corrupted.',\n    });\n  }\n}\n\n/**\n * Builds the method implementation for `snap_manageState`.\n *\n * @param hooks - The RPC method hooks.\n * @param hooks.clearSnapState - A function that clears the state stored for a\n * snap.\n * @param hooks.getSnapState - A function that fetches the persisted decrypted\n * state for a snap.\n * @param hooks.updateSnapState - A function that updates the state stored for a\n * snap.\n * @param hooks.getMnemonic - A function to retrieve the Secret Recovery Phrase\n * of the user.\n * @param hooks.getUnlockPromise - A function that resolves once the MetaMask\n * extension is unlocked and prompts the user to unlock their MetaMask if it is\n * locked.\n * @param hooks.encrypt - A function that encrypts the given state.\n * @param hooks.decrypt - A function that decrypts the given state.\n * @returns The method implementation which either returns `null` for a\n * successful state update/deletion or returns the decrypted state.\n * @throws If the params are invalid.\n */\nexport function getManageStateImplementation({\n  getMnemonic,\n  getUnlockPromise,\n  clearSnapState,\n  getSnapState,\n  updateSnapState,\n  encrypt,\n  decrypt,\n}: ManageStateMethodHooks) {\n  return async function manageState(\n    options: RestrictedMethodOptions<ManageStateParams>,\n  ): Promise<ManageStateResult> {\n    const {\n      params = {},\n      method,\n      context: { origin },\n    } = options;\n    const validatedParams = getValidatedParams(params, method);\n\n    // If the encrypted param is undefined or null we default to true.\n    const shouldEncrypt = validatedParams.encrypted ?? true;\n\n    // We only need to prompt the user when the mnemonic is needed\n    // which it isn't for the clear operation or unencrypted storage.\n    if (\n      shouldEncrypt &&\n      validatedParams.operation !== ManageStateOperation.ClearState\n    ) {\n      await getUnlockPromise(true);\n    }\n\n    switch (validatedParams.operation) {\n      case ManageStateOperation.ClearState:\n        clearSnapState(origin, shouldEncrypt);\n        return null;\n\n      case ManageStateOperation.GetState: {\n        const state = getSnapState(origin, shouldEncrypt);\n        if (state === null) {\n          return state;\n        }\n        return shouldEncrypt\n          ? await decryptState({\n              state,\n              decryptFunction: decrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : parseJson<Record<string, Json>>(state);\n      }\n\n      case ManageStateOperation.UpdateState: {\n        const finalizedState = shouldEncrypt\n          ? await encryptState({\n              state: validatedParams.newState,\n              encryptFunction: encrypt,\n              mnemonicPhrase: await getMnemonic(),\n              snapId: origin,\n            })\n          : JSON.stringify(validatedParams.newState);\n\n        updateSnapState(origin, finalizedState, shouldEncrypt);\n        return null;\n      }\n\n      default:\n        throw rpcErrors.invalidParams(\n          `Invalid ${method} operation: \"${\n            validatedParams.operation as string\n          }\"`,\n        );\n    }\n  };\n}\n\n/**\n * Validates the manageState 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 * @param method - RPC method name used for debugging errors.\n * @param storageSizeLimit - Maximum allowed size (in bytes) of a new state object.\n * @returns The validated method parameter object.\n */\nexport function getValidatedParams(\n  params: unknown,\n  method: string,\n  storageSizeLimit = STORAGE_SIZE_LIMIT,\n): ManageStateParams {\n  if (!isObject(params)) {\n    throw rpcErrors.invalidParams({\n      message: 'Expected params to be a single object.',\n    });\n  }\n\n  const { operation, newState, encrypted } = params;\n\n  if (\n    !operation ||\n    typeof operation !== 'string' ||\n    !Object.values(ManageStateOperation).includes(\n      operation as ManageStateOperation,\n    )\n  ) {\n    throw rpcErrors.invalidParams({\n      message: 'Must specify a valid manage state \"operation\".',\n    });\n  }\n\n  if (encrypted !== undefined && typeof encrypted !== 'boolean') {\n    throw rpcErrors.invalidParams({\n      message: '\"encrypted\" parameter must be a boolean if specified.',\n    });\n  }\n\n  if (operation === ManageStateOperation.UpdateState) {\n    if (!isObject(newState)) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be a plain object.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    let size;\n    try {\n      // `getJsonSize` will throw if the state is not JSON serializable.\n      size = getJsonSize(newState);\n    } catch {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must be JSON serializable.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n\n    if (size > storageSizeLimit) {\n      throw rpcErrors.invalidParams({\n        message: `Invalid ${method} \"updateState\" parameter: The new state must not exceed ${storageSizeLimit} bytes in size.`,\n        data: {\n          receivedNewState:\n            typeof newState === 'undefined' ? 'undefined' : newState,\n        },\n      });\n    }\n  }\n\n  return params as ManageStateParams;\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","ManageStateOperation","STATE_ENCRYPTION_MAGIC_VALUE","parseJson","isObject","getJsonSize","assert","isValidJson","deriveEntropy","STATE_ENCRYPTION_SALT","methodName","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getManageStateImplementation","subjectTypes","Snap","getMnemonic","getUnlockPromise","clearSnapState","getSnapState","updateSnapState","encrypt","decrypt","manageStateBuilder","Object","freeze","STORAGE_SIZE_LIMIT","getEncryptionKey","mnemonicPhrase","snapId","input","salt","magic","encryptState","state","encryptFunction","keyArgs","encryptionKey","decryptState","decryptFunction","decryptedState","internal","message","manageState","options","params","method","context","origin","validatedParams","getValidatedParams","shouldEncrypt","encrypted","operation","ClearState","GetState","UpdateState","finalizedState","newState","JSON","stringify","invalidParams","storageSizeLimit","values","includes","undefined","data","receivedNewState","size"],"mappings":"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"}

package/dist/esm/restricted/notify.js

@@ -1,13 +1,9 @@
 import { PermissionType, SubjectType } from '@metamask/permission-controller';
 import { rpcErrors } from '@metamask/rpc-errors';
-import { assertLinksAreSafe } from '@metamask/snaps-ui';
+import { NotificationType } from '@metamask/snaps-sdk';
+import { validateTextLinks } from '@metamask/snaps-utils';
 import { isObject } from '@metamask/utils';
 const methodName = 'snap_notify';
-export var NotificationType;
-(function(NotificationType) {
-    NotificationType["InApp"] = 'inApp';
-    NotificationType["Native"] = 'native';
-})(NotificationType || (NotificationType = {}));
 /**
  * The specification builder for the `snap_notify` permission.
  * `snap_notify` allows snaps to send multiple types of notifications to its users.
@@ -53,7 +49,7 @@ export const notifyBuilder = Object.freeze({
         const { params, context: { origin } } = args;
         const validatedParams = getValidatedParams(params);
         await maybeUpdatePhishingList();
-        assertLinksAreSafe(validatedParams.message, isOnPhishingList);
+        validateTextLinks(validatedParams.message, isOnPhishingList);
         switch(validatedParams.type){
             case NotificationType.Native:
                 return await showNativeNotification(origin, validatedParams);

package/dist/esm/restricted/notify.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/restricted/notify.ts"],"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 { assertLinksAreSafe } from '@metamask/snaps-ui';\nimport type { EnumToUnion } 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\n// TODO: Move all the types to a shared place when implementing more\n//  notifications.\nexport enum NotificationType {\n  InApp = 'inApp',\n  Native = 'native',\n}\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<NotificationArgs>,\n  ): Promise<null> {\n    const {\n      params,\n      context: { origin },\n    } = args;\n\n    const validatedParams = getValidatedParams(params);\n\n    await maybeUpdatePhishingList();\n\n    assertLinksAreSafe(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): NotificationArgs {\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  // Set to the max message length on a Mac notification for now.\n  if (!message || typeof message !== 'string' || message.length >= 50) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Must specify a non-empty string \"message\" less than 50 characters long.',\n    });\n  }\n\n  return params as NotificationArgs;\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","assertLinksAreSafe","isObject","methodName","NotificationType","InApp","Native","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getImplementation","subjectTypes","Snap","showNativeNotification","showInAppNotification","isOnPhishingList","maybeUpdatePhishingList","notifyBuilder","Object","freeze","implementation","args","params","context","origin","validatedParams","getValidatedParams","message","type","invalidParams","values","includes","length"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AACjD,SAASC,kBAAkB,QAAQ,qBAAqB;AAGxD,SAASC,QAAQ,QAAQ,kBAAkB;AAI3C,MAAMC,aAAa;WAIZ;UAAKC,gBAAgB;IAAhBA,iBACVC,WAAQ;IADED,iBAEVE,YAAS;GAFCF,qBAAAA;AAqDZ;;;;;;;;CAQC,GACD,OAAO,MAAMG,uBAIT,CAAC,EAAEC,iBAAiB,IAAI,EAAEC,WAAW,EAA+B;IACtE,OAAO;QACLC,gBAAgBZ,eAAea,gBAAgB;QAC/CC,YAAYT;QACZK;QACAK,sBAAsBC,kBAAkBL;QACxCM,cAAc;YAAChB,YAAYiB,IAAI;SAAC;IAClC;AACF,EAAE;AAEF,MAAMP,cAAoD;IACxDQ,wBAAwB;IACxBC,uBAAuB;IACvBC,kBAAkB;IAClBC,yBAAyB;AAC3B;AAEA,OAAO,MAAMC,gBAAgBC,OAAOC,MAAM,CAAC;IACzCX,YAAYT;IACZI;IACAE;AACF,GAAY;AAEZ;;;;;;;;;;CAUC,GACD,OAAO,SAASK,kBAAkB,EAChCG,sBAAsB,EACtBC,qBAAqB,EACrBC,gBAAgB,EAChBC,uBAAuB,EACL;IAClB,OAAO,eAAeI,eACpBC,IAA+C;QAE/C,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJ,MAAMI,kBAAkBC,mBAAmBJ;QAE3C,MAAMN;QAENnB,mBAAmB4B,gBAAgBE,OAAO,EAAEZ;QAE5C,OAAQU,gBAAgBG,IAAI;YAC1B,KAAK5B,iBAAiBE,MAAM;gBAC1B,OAAO,MAAMW,uBAAuBW,QAAQC;YAC9C,KAAKzB,iBAAiBC,KAAK;gBACzB,OAAO,MAAMa,sBAAsBU,QAAQC;YAC7C;gBACE,MAAM7B,UAAUiC,aAAa,CAAC;oBAC5BF,SAAS;gBACX;QACJ;IACF;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASD,mBAAmBJ,MAAe;IAChD,IAAI,CAACxB,SAASwB,SAAS;QACrB,MAAM1B,UAAUiC,aAAa,CAAC;YAC5BF,SAAS;QACX;IACF;IAEA,MAAM,EAAEC,IAAI,EAAED,OAAO,EAAE,GAAGL;IAE1B,IACE,CAACM,QACD,OAAOA,SAAS,YAChB,CAACV,OAAOY,MAAM,CAAC9B,kBAAkB+B,QAAQ,CAACH,OAC1C;QACA,MAAMhC,UAAUiC,aAAa,CAAC;YAC5BF,SAAS;QACX;IACF;IAEA,+DAA+D;IAC/D,IAAI,CAACA,WAAW,OAAOA,YAAY,YAAYA,QAAQK,MAAM,IAAI,IAAI;QACnE,MAAMpC,UAAUiC,aAAa,CAAC;YAC5BF,SACE;QACJ;IACF;IAEA,OAAOL;AACT"}
+{"version":3,"sources":["../../../src/restricted/notify.ts"],"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  // Set to the max message length on a Mac notification for now.\n  if (!message || typeof message !== 'string' || message.length >= 50) {\n    throw rpcErrors.invalidParams({\n      message:\n        'Must specify a non-empty string \"message\" less than 50 characters long.',\n    });\n  }\n\n  return params as NotificationArgs;\n}\n"],"names":["PermissionType","SubjectType","rpcErrors","NotificationType","validateTextLinks","isObject","methodName","specificationBuilder","allowedCaveats","methodHooks","permissionType","RestrictedMethod","targetName","methodImplementation","getImplementation","subjectTypes","Snap","showNativeNotification","showInAppNotification","isOnPhishingList","maybeUpdatePhishingList","notifyBuilder","Object","freeze","implementation","args","params","context","origin","validatedParams","getValidatedParams","message","type","Native","InApp","invalidParams","values","includes","length"],"mappings":"AAKA,SAASA,cAAc,EAAEC,WAAW,QAAQ,kCAAkC;AAC9E,SAASC,SAAS,QAAQ,uBAAuB;AACjD,SAASC,gBAAgB,QAAQ,sBAAsB;AAMvD,SAASC,iBAAiB,QAAQ,wBAAwB;AAE1D,SAASC,QAAQ,QAAQ,kBAAkB;AAI3C,MAAMC,aAAa;AAkDnB;;;;;;;;CAQC,GACD,OAAO,MAAMC,uBAIT,CAAC,EAAEC,iBAAiB,IAAI,EAAEC,WAAW,EAA+B;IACtE,OAAO;QACLC,gBAAgBV,eAAeW,gBAAgB;QAC/CC,YAAYN;QACZE;QACAK,sBAAsBC,kBAAkBL;QACxCM,cAAc;YAACd,YAAYe,IAAI;SAAC;IAClC;AACF,EAAE;AAEF,MAAMP,cAAoD;IACxDQ,wBAAwB;IACxBC,uBAAuB;IACvBC,kBAAkB;IAClBC,yBAAyB;AAC3B;AAEA,OAAO,MAAMC,gBAAgBC,OAAOC,MAAM,CAAC;IACzCX,YAAYN;IACZC;IACAE;AACF,GAAY;AAEZ;;;;;;;;;;CAUC,GACD,OAAO,SAASK,kBAAkB,EAChCG,sBAAsB,EACtBC,qBAAqB,EACrBC,gBAAgB,EAChBC,uBAAuB,EACL;IAClB,OAAO,eAAeI,eACpBC,IAA2C;QAE3C,MAAM,EACJC,MAAM,EACNC,SAAS,EAAEC,MAAM,EAAE,EACpB,GAAGH;QAEJ,MAAMI,kBAAkBC,mBAAmBJ;QAE3C,MAAMN;QAENhB,kBAAkByB,gBAAgBE,OAAO,EAAEZ;QAE3C,OAAQU,gBAAgBG,IAAI;YAC1B,KAAK7B,iBAAiB8B,MAAM;gBAC1B,OAAO,MAAMhB,uBAAuBW,QAAQC;YAC9C,KAAK1B,iBAAiB+B,KAAK;gBACzB,OAAO,MAAMhB,sBAAsBU,QAAQC;YAC7C;gBACE,MAAM3B,UAAUiC,aAAa,CAAC;oBAC5BJ,SAAS;gBACX;QACJ;IACF;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASD,mBAAmBJ,MAAe;IAChD,IAAI,CAACrB,SAASqB,SAAS;QACrB,MAAMxB,UAAUiC,aAAa,CAAC;YAC5BJ,SAAS;QACX;IACF;IAEA,MAAM,EAAEC,IAAI,EAAED,OAAO,EAAE,GAAGL;IAE1B,IACE,CAACM,QACD,OAAOA,SAAS,YAChB,CAACV,OAAOc,MAAM,CAACjC,kBAAkBkC,QAAQ,CAACL,OAC1C;QACA,MAAM9B,UAAUiC,aAAa,CAAC;YAC5BJ,SAAS;QACX;IACF;IAEA,+DAA+D;IAC/D,IAAI,CAACA,WAAW,OAAOA,YAAY,YAAYA,QAAQO,MAAM,IAAI,IAAI;QACnE,MAAMpC,UAAUiC,aAAa,CAAC;YAC5BJ,SACE;QACJ;IACF;IAEA,OAAOL;AACT"}

package/dist/types/index.d.ts

@@ -3,4 +3,3 @@ export { handlers as permittedMethods, createSnapsMethodMiddleware, } from './pe
 export * from './restricted';
 export { SnapCaveatType } from '@metamask/snaps-utils';
 export { selectHooks } from './utils';
-export type { RequestFunction, SnapsGlobalObject } from './request';

package/dist/types/permitted/common/snapInstallation.d.ts

@@ -1,7 +1,5 @@
-import type { RequestedPermissions } from '@metamask/permission-controller';
-import type { InstallSnapsResult } from '@metamask/snaps-utils';
-export type { InstallSnapsResult } from '@metamask/snaps-utils';
-export declare type InstallSnapsHook = (requestedSnaps: RequestedPermissions) => Promise<InstallSnapsResult>;
+import type { RequestSnapsParams, RequestSnapsResult } from '@metamask/snaps-sdk';
+export declare type InstallSnapsHook = (requestedSnaps: RequestSnapsParams) => Promise<RequestSnapsResult>;
 /**
  * Typechecks the requested snaps and passes them to the permissions
  * controller for installation.
@@ -13,4 +11,4 @@ export declare type InstallSnapsHook = (requestedSnaps: RequestedPermissions) =>
  * @returns An object containing the installed snaps.
  * @throws If the params are invalid or the snap installation fails.
  */
-export declare function handleInstallSnaps(requestedSnaps: RequestedPermissions, installSnaps: InstallSnapsHook): Promise<InstallSnapsResult>;
+export declare function handleInstallSnaps(requestedSnaps: RequestSnapsParams, installSnaps: InstallSnapsHook): Promise<RequestSnapsResult>;

package/dist/types/permitted/getFile.d.ts

@@ -1,5 +1,6 @@
 import type { PermittedHandlerExport } from '@metamask/permission-controller';
-import type { Infer } from 'superstruct';
+import type { GetFileParams } from '@metamask/snaps-sdk';
+import type { InferMatching } from '@metamask/snaps-utils';
 export declare const GetFileArgsStruct: import("superstruct").Struct<{
     path: string;
     encoding?: "base64" | "utf8" | "hex" | undefined;
@@ -7,8 +8,8 @@ export declare const GetFileArgsStruct: import("superstruct").Struct<{
     path: import("superstruct").Struct<string, null>;
     encoding: import("superstruct").Struct<"base64" | "utf8" | "hex" | undefined, null>;
 }>;
-export declare type GetFileArgs = Infer<typeof GetFileArgsStruct>;
-export declare const getFileHandler: PermittedHandlerExport<GetFileHooks, GetFileArgs, string>;
+export declare type InferredGetFileParams = InferMatching<typeof GetFileArgsStruct, GetFileParams>;
+export declare const getFileHandler: PermittedHandlerExport<GetFileHooks, InferredGetFileParams, string>;
 export declare type GetFileHooks = {
-    getSnapFile: (path: GetFileArgs['path'], encoding: GetFileArgs['encoding']) => Promise<string>;
+    getSnapFile: (path: InferredGetFileParams['path'], encoding: InferredGetFileParams['encoding']) => Promise<string>;
 };

package/dist/types/permitted/getSnaps.d.ts

@@ -1,13 +1,13 @@
 import type { PermittedHandlerExport } from '@metamask/permission-controller';
-import type { InstallSnapsResult } from '@metamask/snaps-utils';
+import type { GetSnapsResult } from '@metamask/snaps-sdk';
 import type { JsonRpcParams } from '@metamask/utils';
 /**
  * `wallet_getSnaps` gets the requester's permitted and installed Snaps.
  */
-export declare const getSnapsHandler: PermittedHandlerExport<GetSnapsHooks, JsonRpcParams, InstallSnapsResult>;
+export declare const getSnapsHandler: PermittedHandlerExport<GetSnapsHooks, JsonRpcParams, GetSnapsResult>;
 export declare type GetSnapsHooks = {
     /**
      * @returns The permitted and installed snaps for the requesting origin.
      */
-    getSnaps: () => Promise<InstallSnapsResult>;
+    getSnaps: () => Promise<GetSnapsResult>;
 };

package/dist/types/permitted/handlers.d.ts

@@ -1,14 +1,8 @@
 export declare const methodHandlers: {
-    wallet_getSnaps: import("@metamask/permission-controller").PermittedHandlerExport<import("./getSnaps").GetSnapsHooks, import("@metamask/utils").JsonRpcParams, import("@metamask/snaps-utils").InstallSnapsResult>;
-    wallet_requestSnaps: import("@metamask/permission-controller").PermittedHandlerExport<import("./requestSnaps").RequestSnapsHooks, import("@metamask/permission-controller").RequestedPermissions, import("@metamask/snaps-utils").InstallSnapsResult>;
-    wallet_invokeSnap: import("@metamask/permission-controller").PermittedHandlerExport<void, import("./invokeSnapSugar").InvokeSnapSugarArgs, import("@metamask/utils").Json>;
-    wallet_invokeKeyring: import("@metamask/permission-controller").PermittedHandlerExport<import("./invokeKeyring").InvokeKeyringHooks, import("@metamask/utils").JsonRpcRequest<import("@metamask/utils").JsonRpcParams>, import("@metamask/utils").Json>;
-    snap_getFile: import("@metamask/permission-controller").PermittedHandlerExport<import("./getFile").GetFileHooks, {
-        path: string;
-        encoding?: "base64" | "utf8" | "hex" | undefined;
-    }, string>;
+    wallet_getSnaps: import("@metamask/permission-controller").PermittedHandlerExport<import("./getSnaps").GetSnapsHooks, import("@metamask/utils").JsonRpcParams, import("@metamask/snaps-sdk").GetSnapsResult>;
+    wallet_requestSnaps: import("@metamask/permission-controller").PermittedHandlerExport<import("./requestSnaps").RequestSnapsHooks, import("@metamask/snaps-sdk").RequestSnapsParams, import("@metamask/snaps-sdk").RequestSnapsResult>;
+    wallet_invokeSnap: import("@metamask/permission-controller").PermittedHandlerExport<void, import("@metamask/snaps-sdk").InvokeSnapParams, import("@metamask/utils").Json>;
+    wallet_invokeKeyring: import("@metamask/permission-controller").PermittedHandlerExport<import("./invokeKeyring").InvokeKeyringHooks, import("@metamask/snaps-sdk").InvokeSnapParams, import("@metamask/utils").Json>;
+    snap_getFile: import("@metamask/permission-controller").PermittedHandlerExport<import("./getFile").GetFileHooks, import("@metamask/snaps-sdk").GetFileParams, string>;
 };
-export declare const handlers: (import("@metamask/permission-controller").PermittedHandlerExport<import("./getSnaps").GetSnapsHooks, import("@metamask/utils").JsonRpcParams, import("@metamask/snaps-utils").InstallSnapsResult> | import("@metamask/permission-controller").PermittedHandlerExport<import("./requestSnaps").RequestSnapsHooks, import("@metamask/permission-controller").RequestedPermissions, import("@metamask/snaps-utils").InstallSnapsResult> | import("@metamask/permission-controller").PermittedHandlerExport<import("./getFile").GetFileHooks, {
-    path: string;
-    encoding?: "base64" | "utf8" | "hex" | undefined;
-}, string> | import("@metamask/permission-controller").PermittedHandlerExport<void, import("./invokeSnapSugar").InvokeSnapSugarArgs, import("@metamask/utils").Json> | import("@metamask/permission-controller").PermittedHandlerExport<import("./invokeKeyring").InvokeKeyringHooks, import("@metamask/utils").JsonRpcRequest<import("@metamask/utils").JsonRpcParams>, import("@metamask/utils").Json>)[];
+export declare const handlers: (import("@metamask/permission-controller").PermittedHandlerExport<import("./getSnaps").GetSnapsHooks, import("@metamask/utils").JsonRpcParams, import("@metamask/snaps-sdk").GetSnapsResult> | import("@metamask/permission-controller").PermittedHandlerExport<import("./requestSnaps").RequestSnapsHooks, import("@metamask/snaps-sdk").RequestSnapsParams, import("@metamask/snaps-sdk").RequestSnapsResult> | import("@metamask/permission-controller").PermittedHandlerExport<import("./getFile").GetFileHooks, import("@metamask/snaps-sdk").GetFileParams, string> | import("@metamask/permission-controller").PermittedHandlerExport<void, import("@metamask/snaps-sdk").InvokeSnapParams, import("@metamask/utils").Json> | import("@metamask/permission-controller").PermittedHandlerExport<import("./invokeKeyring").InvokeKeyringHooks, import("@metamask/snaps-sdk").InvokeSnapParams, import("@metamask/utils").Json>)[];

package/dist/types/permitted/invokeKeyring.d.ts

@@ -1,17 +1,15 @@
 import type { PermittedHandlerExport } from '@metamask/permission-controller';
-import type { Snap } from '@metamask/snaps-utils';
-import { type SnapId, type SnapRpcHookArgs } from '@metamask/snaps-utils';
-import type { JsonRpcRequest } from '@metamask/utils';
-import { type Json } from '@metamask/utils';
+import type { InvokeKeyringResult, InvokeSnapParams } from '@metamask/snaps-sdk';
+import type { Snap, SnapRpcHookArgs } from '@metamask/snaps-utils';
 /**
  * `wallet_invokeKeyring` gets the requester's permitted and installed Snaps.
  */
-export declare const invokeKeyringHandler: PermittedHandlerExport<InvokeKeyringHooks, JsonRpcRequest, Json>;
+export declare const invokeKeyringHandler: PermittedHandlerExport<InvokeKeyringHooks, InvokeSnapParams, InvokeKeyringResult>;
 export declare type InvokeKeyringHooks = {
     hasPermission: (origin: string, permissionName: string) => boolean;
     handleSnapRpcRequest: ({ snapId, origin, handler, request, }: SnapRpcHookArgs & {
-        snapId: SnapId;
+        snapId: string;
     }) => Promise<unknown>;
-    getSnap: (snapId: SnapId) => Snap | undefined;
+    getSnap: (snapId: string) => Snap | undefined;
     getAllowedKeyringMethods: (origin: string) => string[];
 };

package/dist/types/permitted/invokeSnapSugar.d.ts

@@ -1,14 +1,11 @@
 import type { JsonRpcEngineEndCallback, JsonRpcEngineNextCallback } from '@metamask/json-rpc-engine';
 import type { PermittedHandlerExport } from '@metamask/permission-controller';
-import type { Json, JsonRpcRequest } from '@metamask/utils';
-export declare type InvokeSnapSugarArgs = {
-    snapId: string;
-    request: Record<string, Json>;
-};
+import type { InvokeSnapParams, InvokeSnapResult } from '@metamask/snaps-sdk';
+import type { JsonRpcRequest } from '@metamask/utils';
 /**
  * `wallet_invokeSnap` attempts to invoke an RPC method of the specified Snap.
  */
-export declare const invokeSnapSugarHandler: PermittedHandlerExport<void, InvokeSnapSugarArgs, Json>;
+export declare const invokeSnapSugarHandler: PermittedHandlerExport<void, InvokeSnapParams, InvokeSnapResult>;
 /**
  * The `wallet_invokeSnap` method implementation.
  * Reroutes incoming JSON-RPC requests that are targeting snaps, by modifying the method and params.
@@ -21,7 +18,7 @@ export declare const invokeSnapSugarHandler: PermittedHandlerExport<void, Invoke
  * @returns Nothing.
  * @throws If the params are invalid.
  */
-export declare function invokeSnapSugar(req: JsonRpcRequest<InvokeSnapSugarArgs>, _res: unknown, next: JsonRpcEngineNextCallback, end: JsonRpcEngineEndCallback): void;
+export declare function invokeSnapSugar(req: JsonRpcRequest<InvokeSnapParams>, _res: unknown, next: JsonRpcEngineNextCallback, end: JsonRpcEngineEndCallback): void;
 /**
  * Validates the wallet_invokeSnap method `params` and returns them cast to the correct
  * type. Throws if validation fails.
@@ -29,4 +26,4 @@ export declare function invokeSnapSugar(req: JsonRpcRequest<InvokeSnapSugarArgs>
  * @param params - The unvalidated params object from the method request.
  * @returns The validated method parameter object.
  */
-export declare function getValidatedParams(params: unknown): InvokeSnapSugarArgs;
+export declare function getValidatedParams(params: unknown): InvokeSnapParams;

package/dist/types/permitted/requestSnaps.d.ts

@@ -1,10 +1,11 @@
 import type { PermissionConstraint, RequestedPermissions, PermittedHandlerExport } from '@metamask/permission-controller';
+import type { RequestSnapsParams, RequestSnapsResult } from '@metamask/snaps-sdk';
 import type { SnapsPermissionRequest } from '@metamask/snaps-utils';
-import type { InstallSnapsHook, InstallSnapsResult } from './common/snapInstallation';
+import type { InstallSnapsHook } from './common/snapInstallation';
 /**
  * `wallet_requestSnaps` installs the requested Snaps and requests permission to use them if necessary.
  */
-export declare const requestSnapsHandler: PermittedHandlerExport<RequestSnapsHooks, RequestedPermissions, InstallSnapsResult>;
+export declare const requestSnapsHandler: PermittedHandlerExport<RequestSnapsHooks, RequestSnapsParams, RequestSnapsResult>;
 export declare type RequestSnapsHooks = {
     /**
      * Installs the requested snaps if they are permitted.

package/dist/types/restricted/caveats/permittedCoinTypes.d.ts

@@ -1,7 +1,7 @@
 import type { PermissionConstraint, RestrictedMethodCaveatSpecificationConstraint, Caveat } from '@metamask/permission-controller';
+import type { GetBip44EntropyParams } from '@metamask/snaps-sdk';
 import { SnapCaveatType } from '@metamask/snaps-utils';
 import type { Json } from '@metamask/utils';
-import type { GetBip44EntropyParams } from '../getBip44Entropy';
 /**
  * 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

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

@@ -1,16 +1,12 @@
 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 { DialogType } from '@metamask/snaps-sdk';
+import type { DialogParams, EnumToUnion, Component } from '@metamask/snaps-sdk';
+import type { InferMatching } 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>;
@@ -46,67 +42,70 @@ export declare const dialogBuilder: Readonly<{
 }>;
 declare const DialogParametersStruct: Struct<{
     type: "alert";
-    content: import("@metamask/snaps-ui").Panel | {
+    content: import("@metamask/snaps-sdk").Panel | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Copyable;
+        type: import("@metamask/snaps-sdk").NodeType.Copyable;
+        sensitive?: boolean | undefined;
     } | {
-        type: import("@metamask/snaps-ui").NodeType.Divider;
+        type: import("@metamask/snaps-sdk").NodeType.Divider;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Heading;
-    } | {
-        type: import("@metamask/snaps-ui").NodeType.Spinner;
+        type: import("@metamask/snaps-sdk").NodeType.Heading;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Text;
-        markdown?: boolean | undefined;
+        type: import("@metamask/snaps-sdk").NodeType.Image;
+    } | {
+        type: import("@metamask/snaps-sdk").NodeType.Spinner;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Image;
+        type: import("@metamask/snaps-sdk").NodeType.Text;
+        markdown?: boolean | undefined;
     };
 } | {
     type: "confirmation";
-    content: import("@metamask/snaps-ui").Panel | {
+    content: import("@metamask/snaps-sdk").Panel | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Copyable;
+        type: import("@metamask/snaps-sdk").NodeType.Copyable;
+        sensitive?: boolean | undefined;
     } | {
-        type: import("@metamask/snaps-ui").NodeType.Divider;
+        type: import("@metamask/snaps-sdk").NodeType.Divider;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Heading;
-    } | {
-        type: import("@metamask/snaps-ui").NodeType.Spinner;
+        type: import("@metamask/snaps-sdk").NodeType.Heading;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Text;
-        markdown?: boolean | undefined;
+        type: import("@metamask/snaps-sdk").NodeType.Image;
+    } | {
+        type: import("@metamask/snaps-sdk").NodeType.Spinner;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Image;
+        type: import("@metamask/snaps-sdk").NodeType.Text;
+        markdown?: boolean | undefined;
     };
 } | {
     type: "prompt";
-    content: import("@metamask/snaps-ui").Panel | {
+    content: import("@metamask/snaps-sdk").Panel | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Copyable;
+        type: import("@metamask/snaps-sdk").NodeType.Copyable;
+        sensitive?: boolean | undefined;
     } | {
-        type: import("@metamask/snaps-ui").NodeType.Divider;
+        type: import("@metamask/snaps-sdk").NodeType.Divider;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Heading;
-    } | {
-        type: import("@metamask/snaps-ui").NodeType.Spinner;
+        type: import("@metamask/snaps-sdk").NodeType.Heading;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Text;
-        markdown?: boolean | undefined;
+        type: import("@metamask/snaps-sdk").NodeType.Image;
+    } | {
+        type: import("@metamask/snaps-sdk").NodeType.Spinner;
     } | {
         value: string;
-        type: import("@metamask/snaps-ui").NodeType.Image;
+        type: import("@metamask/snaps-sdk").NodeType.Text;
+        markdown?: boolean | undefined;
     };
     placeholder?: string | undefined;
 }, null>;
-export declare type DialogParameters = Infer<typeof DialogParametersStruct>;
+export declare type DialogParameters = InferMatching<typeof DialogParametersStruct, DialogParams>;
 /**
  * Builds the method implementation for `snap_dialog`.
  *

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

@@ -1,7 +1,6 @@
-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 { GetBip32EntropyParams, GetBip32EntropyResult } from '@metamask/snaps-sdk';
 import type { NonEmptyArray } from '@metamask/utils';
 import type { MethodHooksObject } from '../utils';
 declare const targetName = "snap_getBip32Entropy";
@@ -41,5 +40,5 @@ export declare const getBip32EntropyBuilder: Readonly<{
  * @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 declare function getBip32EntropyImplementation({ getMnemonic, getUnlockPromise, }: GetBip32EntropyMethodHooks): (args: RestrictedMethodOptions<GetBip32EntropyParams>) => Promise<GetBip32EntropyResult>;
 export {};

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

@@ -1,5 +1,6 @@
 import type { PermissionSpecificationBuilder, PermissionValidatorConstraint, RestrictedMethodOptions } from '@metamask/permission-controller';
 import { PermissionType } from '@metamask/permission-controller';
+import type { GetBip32PublicKeyParams, GetBip32PublicKeyResult } from '@metamask/snaps-sdk';
 import type { NonEmptyArray } from '@metamask/utils';
 import type { MethodHooksObject } from '../utils';
 declare const targetName = "snap_getBip32PublicKey";
@@ -18,11 +19,6 @@ export declare type GetBip32PublicKeyMethodHooks = {
 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";
@@ -56,5 +52,5 @@ export declare const getBip32PublicKeyBuilder: Readonly<{
  * @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 declare function getBip32PublicKeyImplementation({ getMnemonic, getUnlockPromise, }: GetBip32PublicKeyMethodHooks): (args: RestrictedMethodOptions<GetBip32PublicKeyParams>) => Promise<GetBip32PublicKeyResult>;
 export {};

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

@@ -1,6 +1,6 @@
-import type { JsonBIP44CoinTypeNode } from '@metamask/key-tree';
 import type { PermissionSpecificationBuilder, PermissionValidatorConstraint, RestrictedMethodOptions } from '@metamask/permission-controller';
 import { PermissionType } from '@metamask/permission-controller';
+import type { GetBip44EntropyParams, GetBip44EntropyResult } from '@metamask/snaps-sdk';
 import type { NonEmptyArray } from '@metamask/utils';
 import type { MethodHooksObject } from '../utils';
 declare const targetName = "snap_getBip44Entropy";
@@ -19,9 +19,6 @@ export declare type GetBip44EntropyMethodHooks = {
 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, {
@@ -45,5 +42,5 @@ export declare const getBip44EntropyBuilder: Readonly<{
  * @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 declare function getBip44EntropyImplementation({ getMnemonic, getUnlockPromise, }: GetBip44EntropyMethodHooks): (args: RestrictedMethodOptions<GetBip44EntropyParams>) => Promise<GetBip44EntropyResult>;
 export {};

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

@@ -1,6 +1,7 @@
 import type { PermissionSpecificationBuilder, RestrictedMethodOptions } from '@metamask/permission-controller';
 import { PermissionType } from '@metamask/permission-controller';
-import type { Hex, NonEmptyArray } from '@metamask/utils';
+import type { GetEntropyParams, GetEntropyResult } from '@metamask/snaps-sdk';
+import type { NonEmptyArray } from '@metamask/utils';
 import type { Infer } from 'superstruct';
 import type { MethodHooksObject } from '../utils';
 declare const targetName = "snap_getEntropy";
@@ -56,5 +57,5 @@ export declare type GetEntropyHooks = {
  * once the extension is unlocked.
  * @returns The method implementation.
  */
-declare function getEntropyImplementation({ getMnemonic, getUnlockPromise, }: GetEntropyHooks): (options: RestrictedMethodOptions<GetEntropyArgs>) => Promise<Hex>;
+declare function getEntropyImplementation({ getMnemonic, getUnlockPromise, }: GetEntropyHooks): (options: RestrictedMethodOptions<GetEntropyParams>) => Promise<GetEntropyResult>;
 export {};

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

@@ -1,5 +1,6 @@
 import type { PermissionSpecificationBuilder, ValidPermissionSpecification, RestrictedMethodOptions, RestrictedMethodParameters } from '@metamask/permission-controller';
 import { PermissionType } from '@metamask/permission-controller';
+import type { GetLocaleResult } from '@metamask/snaps-sdk';
 import type { NonEmptyArray } from '@metamask/utils';
 import type { MethodHooksObject } from '../utils';
 declare const methodName = "snap_getLocale";
@@ -43,5 +44,5 @@ export declare const getLocaleBuilder: Readonly<{
  * @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 declare function getImplementation({ getLocale }: GetLocaleMethodHooks): (_args: RestrictedMethodOptions<RestrictedMethodParameters>) => Promise<GetLocaleResult>;
 export {};