@metamask/keyring-api 0.2.7 → 1.0.0

package/CHANGELOG.md

@@ -1,4 +1,5 @@
 # Changelog
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
@@ -6,32 +7,66 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.0]
+
+### Added
+
+- Add migration steps to 1.0.0 ([#149](https://github.com/MetaMask/keyring-api/pull/149)).
+- Add Account Snaps security guidelines ([#143](https://github.com/MetaMask/keyring-api/pull/143)).
+
+### Changed
+
+- Bump @metamask/rpc-errors from 6.0.0 to 6.1.0 ([#151](https://github.com/MetaMask/keyring-api/pull/151)).
+- Bump postcss from 8.4.24 to 8.4.31 ([#150](https://github.com/MetaMask/keyring-api/pull/150)).
+
+## [1.0.0-rc.1]
+
+### Added
+
+- Document how to migrate from API 0.1.x to 0.2.x ([#124](https://github.com/MetaMask/keyring-api/pull/124)).
+
+### Changed
+
+- **BREAKING:** Use the `onKeyringRequest` snap export ([#145](https://github.com/MetaMask/keyring-api/pull/145)).
+- **BREAKING:** Change the events' prefix to `notify:` ([#139](https://github.com/MetaMask/keyring-api/pull/139)).
+
 ## [0.2.7]
+
 ### Added
+
 - Export events types ([#125](https://github.com/MetaMask/keyring-api/pull/125))
 
 ## [0.2.6]
+
 ### Changed
+
 - Remove unused lavamoat allowed scripts ([#122](https://github.com/MetaMask/keyring-api/pull/122)).
 - Update events in sequence diagram ([#121](https://github.com/MetaMask/keyring-api/pull/121)).
 - Update Snap and ESLint dependencies ([#117](https://github.com/MetaMask/keyring-api/pull/117)).
 - Bump @metamask/rpc-methods from 0.38.1-flask.1 to 2.0.0 ([#120](https://github.com/MetaMask/keyring-api/pull/120)).
 
 ## [0.2.5]
+
 ### Changed
+
 - Remove `buildHandlersChain` ([#114](https://github.com/MetaMask/keyring-api/pull/114)).
 - Update doc for `eth_signTransaction` ([#111](https://github.com/MetaMask/keyring-api/pull/111)).
 - Remove un-versioned `eth_signTypedData` method ([#113](https://github.com/MetaMask/keyring-api/pull/113)).
 
 ## [0.2.4]
+
 ### Changed
+
 - Fix linting and compatibility with older `tsc` ([#108](https://github.com/MetaMask/keyring-api/pull/108)).
 
 ## [0.2.3]
+
 ### Added
+
 - Add redirection message to snap async response ([#102](https://github.com/MetaMask/keyring-api/pull/102)).
 
 ### Changed
+
 - Use `Omit` instead of `OmitUnion` ([#106](https://github.com/MetaMask/keyring-api/pull/106)).
 - Update `KeyringResponse` comment ([#103](https://github.com/MetaMask/keyring-api/pull/103)).
 - Use `KeyringRpcMethod` enum instead of string ([#105](https://github.com/MetaMask/keyring-api/pull/105)).
@@ -41,21 +76,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Bump @metamask/providers from 11.1.1 to 11.1.2 ([#98](https://github.com/MetaMask/keyring-api/pull/98)).
 
 ## [0.2.2]
+
 ### Added
+
 - Add architecture and EVM methods docs ([#86](https://github.com/MetaMask/keyring-api/pull/86)).
 - Add `lastSelected` and `lastActive` to metadata ([#92](https://github.com/MetaMask/keyring-api/pull/92)).
 
 ### Changed
+
 - Make request `params` optional ([#96](https://github.com/MetaMask/keyring-api/pull/96)).
 - Remove `lastActive` field from internal account model ([#95](https://github.com/MetaMask/keyring-api/pull/95)).
 - Move request ID to outer request ([#94](https://github.com/MetaMask/keyring-api/pull/94)).
 
 ## [0.2.1]
+
 ### Changed
+
 - Set `snap` object keys to be mandatory and move `name` to `metadata` ([#87](https://github.com/MetaMask/keyring-api/pull/87)).
 
 ## [0.2.0]
+
 ### Added
+
 - Add `InternalAccount` type and create submodule `internal` ([#65](https://github.com/MetaMask/keyring-api/pull/65)).
 - Add keyring events and helper functions ([#74](https://github.com/MetaMask/keyring-api/pull/74)).
 - Add a `redirect` field to asynchronous request responses ([#75](https://github.com/MetaMask/keyring-api/pull/75)).
@@ -63,6 +105,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add `getController` to client ([#43](https://github.com/MetaMask/keyring-api/pull/43)).
 
 ### Changed
+
 - Rename `erc4337` -> `eip4337` ([#42](https://github.com/MetaMask/keyring-api/pull/42)).
 - Make `options` a mandatory field of `KeyringAccount` ([#30](https://github.com/MetaMask/keyring-api/pull/30)).
 - Make `approveRequest` and `rejectRequest` optional ([#63](https://github.com/MetaMask/keyring-api/pull/63)).
@@ -74,29 +117,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Rename `supportedMethods` to `methods` ([#35](https://github.com/MetaMask/keyring-api/pull/35)).
 
 ## [0.1.3]
+
 ### Changed
+
 - Downgrade snaps dependencies to `0.35.2-flask.1` ([#25](https://github.com/MetaMask/keyring-api/pull/25)).
 
 ## [0.1.2]
+
 ### Changed
+
 - Update snaps dependencies ([#21](https://github.com/MetaMask/keyring-api/pull/21)).
 
 ## [0.1.1]
+
 ### Added
+
 - Validate snap responses for type correctness ([#15](https://github.com/MetaMask/keyring-api/pull/15)).
 
 ### Changed
+
 - Rename RPC handling functions ([#16](https://github.com/MetaMask/keyring-api/pull/16)).
 
 ## [0.1.0] - 2023-06-20
+
 ### Added
+
 - Usage examples to [`README.md`](./README.md).
 - Keyring API definition.
-- JSON-RPC snap keyring client. It is intended to be used by a snap's companion dApp to send requests to the snap.
+- JSON-RPC snap keyring client. It is intended to be used by a snap's companion dapp to send requests to the snap.
 - SnapController keyring client. It is intended to be used by MetaMask to talk to the snap.
 - Helper functions to create keyring handler in the snap.
 
-[Unreleased]: https://github.com/MetaMask/keyring-api/compare/v0.2.7...HEAD
+[Unreleased]: https://github.com/MetaMask/keyring-api/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/MetaMask/keyring-api/compare/v1.0.0-rc.1...v1.0.0
+[1.0.0-rc.1]: https://github.com/MetaMask/keyring-api/compare/v0.2.7...v1.0.0-rc.1
 [0.2.7]: https://github.com/MetaMask/keyring-api/compare/v0.2.6...v0.2.7
 [0.2.6]: https://github.com/MetaMask/keyring-api/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/MetaMask/keyring-api/compare/v0.2.4...v0.2.5

package/README.md

@@ -2,7 +2,7 @@
 
 > This TypeScript module is maintained in the style of the MetaMask team.
 
-This TypeScript module simplifies the integration of snaps with MetaMask using
+This TypeScript module simplifies the integration of Snaps with MetaMask using
 the Keyring API.
 
 Features:
@@ -11,19 +11,19 @@ Features:
   Keyring API. Snaps can implement this interface to seamlessly interact with
   MetaMask and leverage its functionality.
 
-- **DApp Client**: The module includes a client that enables dApps to
-  communicate with the Keyring snap. This client allows dApps to send requests
-  to the snap, such as retrieving account information or submitting requests.
+- **Dapp Client**: The module includes a client that enables dapps to
+  communicate with the Keyring Snap. This client allows dapps to send requests
+  to the Snap, such as retrieving account information or submitting requests.
 
 - **MetaMask Client**: The module provides a client specifically designed for
   MetaMask integration. This client enables MetaMask to send requests directly
-  to the Keyring snap, facilitating smooth interoperability between the two
+  to the Keyring Snap, facilitating smooth interoperability between the two
   applications.
 
 - **Request Handler Helper Functions**: The module offers a set of helper
   functions to simplify the implementation of the request handler in the
-  Keyring snap. These functions assist in processing incoming requests,
-  validating data, and handling various request types from dApps and MetaMask.
+  Keyring Snap. These functions assist in processing incoming requests,
+  validating data, and handling various request types from dapps and MetaMask.
 
 ## Installation
 
@@ -33,52 +33,308 @@ or
 
 `npm install @metamask/keyring-api`
 
-## Usage
+## Keyring Snaps
 
-### In a snap
+Starting with MetaMask 11.5, Snaps can implement the Keyring API. This allows
+users to manage their accounts in a more flexible way, and enables developers
+to build new types of accounts.
 
-Inside the snap, implement the `Keyring` API:
+> [!IMPORTANT]
+> Before implementing your Snap, please make sure to read the [security
+> recommendations](./docs/security.md) and the [architecture
+> document](./docs/architecture.md).
 
-```typescript
-class MySnapKeyring implements Keyring {
-  // Implement the required methods.
-}
-```
+Follow these steps to implement the Keyring API in your Snap. Please note that
+these instruction assume that you are already familiar with the process of
+[developing a Snap](https://docs.metamask.io/).
 
-Then create a handler that uses an instance of your keyring:
+1. **Implement the Keyring API:**
 
-```typescript
-import { keyringRpcDispatcher } from '@metamask/keyring-api';
+   Inside your Snap, implement the `Keyring` API:
 
-// Create a new MySnapKeyring instance
-keyring = new MySnapKeyring(keyringState);
-// ...
+   ```typescript
+   class MySnapKeyring implements Keyring {
+     // Implement the required methods here...
+   }
+   ```
 
-// And wrap it in a handler
-const keyringHandler: OnRpcRequestHandler = async ({ request }) => {
-  // Load the keyring state if needed
-  // ...
-  return await keyringRpcDispatcher(keyring, request);
-};
-```
+   > [!WARNING]
+   > Ensure that your keyring implements the [methods called by
+   > MetaMask](./docs/security.md#limit-the-methods-exposed-to-dapps),
+   > otherwise some features may not work.
 
-Now expose this handler:
+2. **Handle requests submitted by MetaMask:**
 
-```typescript
-export const onRpcRequest: OnRpcRequestHandler = keyringHandler;
-```
+   MetaMask will submit requests through the `submitRequest` method of your the
+   Keyring API (check the supported [EVM methods](./docs/evm_methods.md)). Here
+   is an example of request:
 
-Or chain it with other handlers:
+   ```json
+   {
+     "id": "d6e23af6-4bea-48dd-aeb0-7d3c30ea67f9",
+     "scope": "",
+     "account": "69438371-bef3-4957-9f91-c3f22c1d75f3",
+     "request": {
+       "method": "personal_sign",
+       "params": [
+         "0x4578616d706c652060706572736f6e616c5f7369676e60206d657373616765",
+         "0x5874174dcf1ab6F7Efd8496f4f09404CD1c5bA84"
+       ]
+     }
+   }
+   ```
 
-```typescript
-import { chainHandlers } from '@metamask/keyring-api';
+   Where:
 
-export const onRpcRequest: OnRpcRequestHandler = chainHandlers(
-  // Other handlers...
-  keyringHandler,
-  // Other handlers...
-);
-```
+   - `id` is unique identifier for the request.
+
+   - `scope` is the CAIP-2 chain ID of the selected chain. Currently, this
+     property is always an empty string. Your Snap should use the chain ID
+     present in the request object instead.
+
+   - `account` is the ID of the account that should handle the request.
+
+   - `request` is the request object.
+
+   Your Snap must respond with either a synchronous result:
+
+   ```typescript
+   return { pending: false, result };
+   ```
+
+   Or an asynchronous result:
+
+   ```typescript
+   return { pending: true, redirect: { message, url } };
+   ```
+
+   The redirect message and URL will be displayed to the user to inform them
+   about how to continue the transaction flow.
+
+3. **Notify MetaMask about events:**
+
+   The following actions must be notified to MetaMask:
+
+   1. When an account is created:
+
+      ```typescript
+      try {
+        emitSnapKeyringEvent(snap, KeyringEvent.AccountCreated, { account });
+        // Update your snap's state...
+      } catch (error) {
+        // Handle the error...
+      }
+      ```
+
+      MetaMask will return an error if the account already exists or if the
+      account object is invalid.
+
+   2. When an account is updated:
+
+      ```typescript
+      try {
+        emitSnapKeyringEvent(snap, KeyringEvent.AccountUpdated, { account });
+        // Update your snap's state...
+      } catch (error) {
+        // Handle the error...
+      }
+      ```
+
+      MetaMask will return an error if the account does not exist, if the
+      account object is invalid, or if the account address changed.
+
+   3. When an account is deleted:
+
+      ```typescript
+      try {
+        emitSnapKeyringEvent(snap, KeyringEvent.AccountDeleted, {
+          id: account.id,
+        });
+        // Update your snap's state...
+      } catch (error) {
+        // Handle the error...
+      }
+      ```
+
+      The delete event is idempotent, so it is safe to emit it even if the
+      account does not exist.
+
+   4. When a request is approved:
+
+      ```typescript
+      try {
+        emitSnapKeyringEvent(snap, KeyringEvent.RequestApproved, {
+          id: request.id,
+          result,
+        });
+        // Update your snap's state...
+      } catch (error) {
+        // Handle the error...
+      }
+      ```
+
+      MetaMask will return an error if the request does not exist.
+
+      > [!NOTE]
+      > This only applies to Snaps that implement the [async
+      > flow](./docs/architecture.md#transaction-flow).
+
+   5. When a request is rejected:
+
+      ```typescript
+      try {
+        emitSnapKeyringEvent(snap, KeyringEvent.RequestRejected, {
+          id: request.id,
+        });
+        // Update your snap's state...
+      } catch (error) {
+        // Handle the error...
+      }
+      ```
+
+      MetaMask will return an error if the request does not exist.
+
+      > [!NOTE]
+      > This only applies to Snaps that implement the [async
+      > flow](./docs/architecture.md#transaction-flow).
+
+4. **Expose the Keyring API:**
+
+   Then create a handler to expose the keyring methods to MetaMask and your dapp:
+
+   ```typescript
+   export const onKeyringRequest: OnKeyringRequestHandler = async ({
+     origin,
+     request,
+   }) => {
+     // Your custom logic here...
+     return handleKeyringRequest(keyring, request);
+   };
+   ```
+
+5. **Call the keyring methods from your dapp:**
+
+   Now you should be able to call your Keyring Snap from your dapp, for
+   example:
+
+   ```typescript
+   const client = new KeyringSnapRpcClient(snapId, window.ethereum);
+   const accounts = await client.listAccounts();
+   ```
+
+## Migrating from 0.1.x to 0.2.x
+
+The following changes were made to the API, which may require changes to your
+implementation:
+
+- In the `KeyringAccount` type, the `supportedMethods` property was renamed to
+  `methods`.
+
+  ```diff
+  - supportedMethods: string[];
+  + methods: string[];
+  ```
+
+- In the `KeyringAccount` type, the `name` property was removed.
+
+  ```diff
+  - name: string;
+  ```
+
+- In the `KeyringAccount` type, add the `options` property can no longer be
+  null.
+
+  ```diff
+  - options: Record<string, unknown> | null;
+  + options: Record<string, unknown>;
+  ```
+
+- In the `KeyringAccount` type, the `eth_signTypedData` method was removed from
+  the list of available methods.
+
+  ```diff
+  - 'eth_signTypedData',
+  ```
+
+  It was an alias for the `eth_signTypedData_v1` method, which is still
+  present.
+
+- Snaps should now use the `emitSnapKeyringEvent()` helper function to notify
+  MetaMask about events:
+
+  ```ts
+  // Emit an event to indicate that an account was created.
+  emitSnapKeyringEvent(snap, KeyringEvent.AccountCreated, { account });
+
+  // Emit an event to indicate that an account was updated.
+  emitSnapKeyringEvent(snap, KeyringEvent.AccountUpdated, { account });
+
+  // Emit an event to indicate that an account was deleted.
+  emitSnapKeyringEvent(snap, KeyringEvent.AccountDeleted, { id: account.id });
+
+  // Emit an event to indicate that a request was approved.
+  emitSnapKeyringEvent(snap, KeyringEvent.RequestApproved, {
+    id: request.id,
+    result,
+  });
+
+  // Emit an event to indicate that a request was rejected.
+  emitSnapKeyringEvent(snap, KeyringEvent.RequestRejected, { id: request.id });
+  ```
+
+  > [!IMPORTANT]
+  > For all events above, MetaMask may return an error indicating that the
+  > event was not handled, possibly because it contains invalid arguments.
+
+- Keyrings that implement the [async transaction
+  flow](./docs/architecture.md#transaction-flow) can now return an optional
+  `redirect` property that contains an URL and a message to be displayed to the
+  user. This will, in a future release of MetaMask, be used to inform the user
+  on how to continue the transaction flow.
+
+  ```ts
+  return {
+    pending: true,
+    redirect: {
+      message: 'Please go to the Snap Dapp to finish sining the transaction.',
+      url: 'https://example.com/sign?tx=1234',
+    },
+  };
+  ```
+
+- The `buildHandlersChain` helper function was removed from the API. Instead,
+  you must implement your own handler. For example:
+
+  ```ts
+  export const onRpcRequest: OnRpcRequestHandler = async ({
+    request,
+    origin,
+  }) => {
+    // Check if origin is allowed to call the method.
+    if (!hasPermission(origin, request.method)) {
+      throw new Error(
+        `Origin '${origin}' is not allowed to call '${request.method}'`,
+      );
+    }
+
+    // Dispatch the request to the keyring.
+    return handleKeyringRequest(keyring, request);
+  };
+  ```
+
+## Migrating from 0.2.x to 1.x.x
+
+The following changes were made to the API, which may require changes to your
+implementation:
+
+- Your Snap must expose the Keyring methods through the `onKeyringRequest`
+  export instead of the `onRpcRequest` export.
+
+- Your Snap must request the new `endowment:keyring` endowment, and list any
+  dapp that should be allowed to call the Keyring methods.
+
+For more details about the changes, please refer to the [security
+guidelines](./docs/security.md).
 
 ## API
 
@@ -124,7 +380,7 @@ The project follows the same release process as the other libraries in the MetaM
    - Generally any changes that don't affect consumers of the package (e.g. lockfile changes or development environment changes) are omitted. Exceptions may be made for changes that might be of interest despite not having an effect upon the published package (e.g. major test improvements, security improvements, improved documentation, etc.).
    - Try to explain each change in terms that users of the package would understand (e.g. avoid referencing internal variables/concepts).
    - Consolidate related changes into one change entry if it makes it easier to explain.
-   - Run `yarn auto-changelog validate --rc` to check that the changelog is correctly formatted.
+   - Run `yarn auto-changelog validate --prettier --rc` to check that the changelog is correctly formatted.
 
 5. Review and QA the release.
 

package/dist/KeyringSnapControllerClient.d.ts

@@ -18,7 +18,7 @@ export declare class KeyringSnapControllerClient extends KeyringClient {
      * @param args.controller - The `SnapController` instance to use.
      * @param args.snapId - The ID of the snap to use (default: `'undefined'`).
      * @param args.origin - The sender's origin (default: `'metamask'`).
-     * @param args.handler - The handler type (default: `'onRpcRequest'`).
+     * @param args.handler - The handler type (default: `'onKeyringRequest'`).
      */
     constructor({ controller, snapId, origin, handler, }: {
         controller: SnapController;

package/dist/KeyringSnapControllerClient.js

@@ -69,9 +69,9 @@ class KeyringSnapControllerClient extends KeyringClient_1.KeyringClient {
      * @param args.controller - The `SnapController` instance to use.
      * @param args.snapId - The ID of the snap to use (default: `'undefined'`).
      * @param args.origin - The sender's origin (default: `'metamask'`).
-     * @param args.handler - The handler type (default: `'onRpcRequest'`).
+     * @param args.handler - The handler type (default: `'onKeyringRequest'`).
      */
-    constructor({ controller, snapId = 'undefined', origin = 'metamask', handler = 'onRpcRequest', }) {
+    constructor({ controller, snapId = 'undefined', origin = 'metamask', handler = 'onKeyringRequest', }) {
         super(new SnapControllerSender(controller, snapId, origin, handler));
         _KeyringSnapControllerClient_controller.set(this, void 0);
         __classPrivateFieldSet(this, _KeyringSnapControllerClient_controller, controller, "f");

package/dist/KeyringSnapControllerClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"KeyringSnapControllerClient.js","sourceRoot":"","sources":["../src/KeyringSnapControllerClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAKA,mDAA6D;AAE7D;;;GAGG;AACH,MAAM,oBAAoB;IASxB;;;;;;;OAOG;IACH,YACE,UAAe,EACf,MAAc,EACd,MAAc,EACd,OAAoB;QApBtB,+CAAgB;QAEhB,+CAAgB;QAEhB,mDAA4B;QAE5B,gDAAsB;QAgBpB,uBAAA,IAAI,oCAAe,UAAU,MAAA,CAAC;QAC9B,uBAAA,IAAI,gCAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,gCAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,iCAAY,OAAO,MAAA,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,OAAO,uBAAA,IAAI,wCAAY,CAAC,aAAa,CAAC;YACpC,MAAM,EAAE,uBAAA,IAAI,oCAA2B;YACvC,MAAM,EAAE,uBAAA,IAAI,oCAAQ;YACpB,OAAO,EAAE,uBAAA,IAAI,qCAAS;YACtB,OAAO;SACR,CAAkB,CAAC;IACtB,CAAC;CACF;;AAED;;;GAGG;AACH,MAAa,2BAA4B,SAAQ,6BAAa;IAG5D;;;;;;;;;;;;OAYG;IACH,YAAY,EACV,UAAU,EACV,MAAM,GAAG,WAAW,EACpB,MAAM,GAAG,UAAU,EACnB,OAAO,GAAG,cAA6B,GAMxC;QACC,KAAK,CAAC,IAAI,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QA1BvE,0DAA4B;QA2B1B,uBAAA,IAAI,2CAAe,UAAU,MAAA,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,MAAc;QACvB,OAAO,IAAI,2BAA2B,CAAC;YACrC,UAAU,EAAE,uBAAA,IAAI,+CAAY;YAC5B,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,OAAO,uBAAA,IAAI,+CAAY,CAAC;IAC1B,CAAC;CACF;AAtDD,kEAsDC","sourcesContent":["import type { SnapController } from '@metamask/snaps-controllers';\nimport type { HandlerType, ValidatedSnapId } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\n\nimport type { JsonRpcRequest } from './JsonRpcRequest';\nimport { KeyringClient, type Sender } from './KeyringClient';\n\n/**\n * Implementation of the `Sender` interface that can be used to send requests\n * to a snap through a `SnapController`.\n */\nclass SnapControllerSender implements Sender {\n  #snapId: string;\n\n  #origin: string;\n\n  #controller: SnapController;\n\n  #handler: HandlerType;\n\n  /**\n   * Create a new instance of `SnapControllerSender`.\n   *\n   * @param controller - The `SnapController` instance to send requests to.\n   * @param snapId - The ID of the snap to use.\n   * @param origin - The sender's origin.\n   * @param handler - The handler type.\n   */\n  constructor(\n    controller: any,\n    snapId: string,\n    origin: string,\n    handler: HandlerType,\n  ) {\n    this.#controller = controller;\n    this.#snapId = snapId;\n    this.#origin = origin;\n    this.#handler = handler;\n  }\n\n  /**\n   * Send a request to the snap and return the response.\n   *\n   * @param request - JSON-RPC request to send to the snap.\n   * @returns A promise that resolves to the response of the request.\n   */\n  async send(request: JsonRpcRequest): Promise<Json> {\n    return this.#controller.handleRequest({\n      snapId: this.#snapId as ValidatedSnapId,\n      origin: this.#origin,\n      handler: this.#handler,\n      request,\n    }) as Promise<Json>;\n  }\n}\n\n/**\n * A `KeyringClient` that allows the communication with a snap through the\n * `SnapController`.\n */\nexport class KeyringSnapControllerClient extends KeyringClient {\n  #controller: SnapController;\n\n  /**\n   * Create a new instance of `KeyringSnapControllerClient`.\n   *\n   * The `handlerType` argument has a hard-coded default `string` value instead\n   * of a `HandlerType` value to prevent the `@metamask/snaps-utils` module\n   * from being required at runtime.\n   *\n   * @param args - Constructor arguments.\n   * @param args.controller - The `SnapController` instance to use.\n   * @param args.snapId - The ID of the snap to use (default: `'undefined'`).\n   * @param args.origin - The sender's origin (default: `'metamask'`).\n   * @param args.handler - The handler type (default: `'onRpcRequest'`).\n   */\n  constructor({\n    controller,\n    snapId = 'undefined',\n    origin = 'metamask',\n    handler = 'onRpcRequest' as HandlerType,\n  }: {\n    controller: SnapController;\n    snapId?: string;\n    origin?: string;\n    handler?: HandlerType;\n  }) {\n    super(new SnapControllerSender(controller, snapId, origin, handler));\n    this.#controller = controller;\n  }\n\n  /**\n   * Create a new instance of `KeyringSnapControllerClient` with the specified\n   * `snapId`.\n   *\n   * @param snapId - The ID of the snap to use in the new instance.\n   * @returns A new instance of `KeyringSnapControllerClient` with the\n   * specified snap ID.\n   */\n  withSnapId(snapId: string): KeyringSnapControllerClient {\n    return new KeyringSnapControllerClient({\n      controller: this.#controller,\n      snapId,\n    });\n  }\n\n  /**\n   * Get the `SnapController` instance used by this client.\n   *\n   * @returns The `SnapController` instance used by this client.\n   */\n  getController(): SnapController {\n    return this.#controller;\n  }\n}\n"]}
+{"version":3,"file":"KeyringSnapControllerClient.js","sourceRoot":"","sources":["../src/KeyringSnapControllerClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAKA,mDAA6D;AAE7D;;;GAGG;AACH,MAAM,oBAAoB;IASxB;;;;;;;OAOG;IACH,YACE,UAAe,EACf,MAAc,EACd,MAAc,EACd,OAAoB;QApBtB,+CAAgB;QAEhB,+CAAgB;QAEhB,mDAA4B;QAE5B,gDAAsB;QAgBpB,uBAAA,IAAI,oCAAe,UAAU,MAAA,CAAC;QAC9B,uBAAA,IAAI,gCAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,gCAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,iCAAY,OAAO,MAAA,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,OAAO,uBAAA,IAAI,wCAAY,CAAC,aAAa,CAAC;YACpC,MAAM,EAAE,uBAAA,IAAI,oCAA2B;YACvC,MAAM,EAAE,uBAAA,IAAI,oCAAQ;YACpB,OAAO,EAAE,uBAAA,IAAI,qCAAS;YACtB,OAAO;SACR,CAAkB,CAAC;IACtB,CAAC;CACF;;AAED;;;GAGG;AACH,MAAa,2BAA4B,SAAQ,6BAAa;IAG5D;;;;;;;;;;;;OAYG;IACH,YAAY,EACV,UAAU,EACV,MAAM,GAAG,WAAW,EACpB,MAAM,GAAG,UAAU,EACnB,OAAO,GAAG,kBAAiC,GAM5C;QACC,KAAK,CAAC,IAAI,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QA1BvE,0DAA4B;QA2B1B,uBAAA,IAAI,2CAAe,UAAU,MAAA,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAC,MAAc;QACvB,OAAO,IAAI,2BAA2B,CAAC;YACrC,UAAU,EAAE,uBAAA,IAAI,+CAAY;YAC5B,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,OAAO,uBAAA,IAAI,+CAAY,CAAC;IAC1B,CAAC;CACF;AAtDD,kEAsDC","sourcesContent":["import type { SnapController } from '@metamask/snaps-controllers';\nimport type { HandlerType, ValidatedSnapId } from '@metamask/snaps-utils';\nimport type { Json } from '@metamask/utils';\n\nimport type { JsonRpcRequest } from './JsonRpcRequest';\nimport { KeyringClient, type Sender } from './KeyringClient';\n\n/**\n * Implementation of the `Sender` interface that can be used to send requests\n * to a snap through a `SnapController`.\n */\nclass SnapControllerSender implements Sender {\n  #snapId: string;\n\n  #origin: string;\n\n  #controller: SnapController;\n\n  #handler: HandlerType;\n\n  /**\n   * Create a new instance of `SnapControllerSender`.\n   *\n   * @param controller - The `SnapController` instance to send requests to.\n   * @param snapId - The ID of the snap to use.\n   * @param origin - The sender's origin.\n   * @param handler - The handler type.\n   */\n  constructor(\n    controller: any,\n    snapId: string,\n    origin: string,\n    handler: HandlerType,\n  ) {\n    this.#controller = controller;\n    this.#snapId = snapId;\n    this.#origin = origin;\n    this.#handler = handler;\n  }\n\n  /**\n   * Send a request to the snap and return the response.\n   *\n   * @param request - JSON-RPC request to send to the snap.\n   * @returns A promise that resolves to the response of the request.\n   */\n  async send(request: JsonRpcRequest): Promise<Json> {\n    return this.#controller.handleRequest({\n      snapId: this.#snapId as ValidatedSnapId,\n      origin: this.#origin,\n      handler: this.#handler,\n      request,\n    }) as Promise<Json>;\n  }\n}\n\n/**\n * A `KeyringClient` that allows the communication with a snap through the\n * `SnapController`.\n */\nexport class KeyringSnapControllerClient extends KeyringClient {\n  #controller: SnapController;\n\n  /**\n   * Create a new instance of `KeyringSnapControllerClient`.\n   *\n   * The `handlerType` argument has a hard-coded default `string` value instead\n   * of a `HandlerType` value to prevent the `@metamask/snaps-utils` module\n   * from being required at runtime.\n   *\n   * @param args - Constructor arguments.\n   * @param args.controller - The `SnapController` instance to use.\n   * @param args.snapId - The ID of the snap to use (default: `'undefined'`).\n   * @param args.origin - The sender's origin (default: `'metamask'`).\n   * @param args.handler - The handler type (default: `'onKeyringRequest'`).\n   */\n  constructor({\n    controller,\n    snapId = 'undefined',\n    origin = 'metamask',\n    handler = 'onKeyringRequest' as HandlerType,\n  }: {\n    controller: SnapController;\n    snapId?: string;\n    origin?: string;\n    handler?: HandlerType;\n  }) {\n    super(new SnapControllerSender(controller, snapId, origin, handler));\n    this.#controller = controller;\n  }\n\n  /**\n   * Create a new instance of `KeyringSnapControllerClient` with the specified\n   * `snapId`.\n   *\n   * @param snapId - The ID of the snap to use in the new instance.\n   * @returns A new instance of `KeyringSnapControllerClient` with the\n   * specified snap ID.\n   */\n  withSnapId(snapId: string): KeyringSnapControllerClient {\n    return new KeyringSnapControllerClient({\n      controller: this.#controller,\n      snapId,\n    });\n  }\n\n  /**\n   * Get the `SnapController` instance used by this client.\n   *\n   * @returns The `SnapController` instance used by this client.\n   */\n  getController(): SnapController {\n    return this.#controller;\n  }\n}\n"]}

package/dist/KeyringSnapRpcClient.js

@@ -39,7 +39,7 @@ class SnapRpcSender {
      */
     async send(request) {
         return __classPrivateFieldGet(this, _SnapRpcSender_provider, "f").request({
-            method: 'wallet_invokeSnap',
+            method: 'wallet_invokeKeyring',
             params: {
                 snapId: __classPrivateFieldGet(this, _SnapRpcSender_origin, "f"),
                 request,

package/dist/KeyringSnapRpcClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"KeyringSnapRpcClient.js","sourceRoot":"","sources":["../src/KeyringSnapRpcClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAKA,mDAAgD;AAEhD;;;GAGG;AACH,MAAa,aAAa;IAKxB;;;;;OAKG;IACH,YAAY,MAAc,EAAE,QAAgC;QAV5D,wCAAgB;QAEhB,0CAAkC;QAShC,uBAAA,IAAI,yBAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,2BAAa,QAAQ,MAAA,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,OAAO,uBAAA,IAAI,+BAAU,CAAC,OAAO,CAAC;YAC5B,MAAM,EAAE,mBAAmB;YAC3B,MAAM,EAAE;gBACN,MAAM,EAAE,uBAAA,IAAI,6BAAQ;gBACpB,OAAO;aACR;SACF,CAAkB,CAAC;IACtB,CAAC;CACF;AA/BD,sCA+BC;;AAED;;;GAGG;AACH,MAAa,oBAAqB,SAAQ,6BAAa;IACrD;;;;;OAKG;IACH,YAAY,MAAc,EAAE,QAAgC;QAC1D,KAAK,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC7C,CAAC;CACF;AAVD,oDAUC","sourcesContent":["import type { MetaMaskInpageProvider } from '@metamask/providers';\nimport type { Json } from '@metamask/utils';\n\nimport type { JsonRpcRequest } from './JsonRpcRequest';\nimport type { Sender } from './KeyringClient';\nimport { KeyringClient } from './KeyringClient';\n\n/**\n * Implementation of the `Sender` interface that can be used to send requests\n * to a snap through the snap JSON-RPC API.\n */\nexport class SnapRpcSender implements Sender {\n  #origin: string;\n\n  #provider: MetaMaskInpageProvider;\n\n  /**\n   * Create a new instance of `SnapRpcSender`.\n   *\n   * @param origin - The caller's origin.\n   * @param provider - The `MetaMaskInpageProvider` instance to use.\n   */\n  constructor(origin: string, provider: MetaMaskInpageProvider) {\n    this.#origin = origin;\n    this.#provider = provider;\n  }\n\n  /**\n   * Send a request to the snap and return the response.\n   *\n   * @param request - The JSON-RPC request to send to the snap.\n   * @returns A promise that resolves to the response of the request.\n   */\n  async send(request: JsonRpcRequest): Promise<Json> {\n    return this.#provider.request({\n      method: 'wallet_invokeSnap',\n      params: {\n        snapId: this.#origin,\n        request,\n      },\n    }) as Promise<Json>;\n  }\n}\n\n/**\n * A `KeyringClient` that allows the communication with a snap through the snap\n * JSON-RPC API.\n */\nexport class KeyringSnapRpcClient extends KeyringClient {\n  /**\n   * Create a new instance of `KeyringSnapRpcClient`.\n   *\n   * @param origin - Caller's origin.\n   * @param provider - The `MetaMaskInpageProvider` instance to use.\n   */\n  constructor(origin: string, provider: MetaMaskInpageProvider) {\n    super(new SnapRpcSender(origin, provider));\n  }\n}\n"]}
+{"version":3,"file":"KeyringSnapRpcClient.js","sourceRoot":"","sources":["../src/KeyringSnapRpcClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAKA,mDAAgD;AAEhD;;;GAGG;AACH,MAAa,aAAa;IAKxB;;;;;OAKG;IACH,YAAY,MAAc,EAAE,QAAgC;QAV5D,wCAAgB;QAEhB,0CAAkC;QAShC,uBAAA,IAAI,yBAAW,MAAM,MAAA,CAAC;QACtB,uBAAA,IAAI,2BAAa,QAAQ,MAAA,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,OAAO,uBAAA,IAAI,+BAAU,CAAC,OAAO,CAAC;YAC5B,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE;gBACN,MAAM,EAAE,uBAAA,IAAI,6BAAQ;gBACpB,OAAO;aACR;SACF,CAAkB,CAAC;IACtB,CAAC;CACF;AA/BD,sCA+BC;;AAED;;;GAGG;AACH,MAAa,oBAAqB,SAAQ,6BAAa;IACrD;;;;;OAKG;IACH,YAAY,MAAc,EAAE,QAAgC;QAC1D,KAAK,CAAC,IAAI,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC7C,CAAC;CACF;AAVD,oDAUC","sourcesContent":["import type { MetaMaskInpageProvider } from '@metamask/providers';\nimport type { Json } from '@metamask/utils';\n\nimport type { JsonRpcRequest } from './JsonRpcRequest';\nimport type { Sender } from './KeyringClient';\nimport { KeyringClient } from './KeyringClient';\n\n/**\n * Implementation of the `Sender` interface that can be used to send requests\n * to a snap through the snap JSON-RPC API.\n */\nexport class SnapRpcSender implements Sender {\n  #origin: string;\n\n  #provider: MetaMaskInpageProvider;\n\n  /**\n   * Create a new instance of `SnapRpcSender`.\n   *\n   * @param origin - The caller's origin.\n   * @param provider - The `MetaMaskInpageProvider` instance to use.\n   */\n  constructor(origin: string, provider: MetaMaskInpageProvider) {\n    this.#origin = origin;\n    this.#provider = provider;\n  }\n\n  /**\n   * Send a request to the snap and return the response.\n   *\n   * @param request - The JSON-RPC request to send to the snap.\n   * @returns A promise that resolves to the response of the request.\n   */\n  async send(request: JsonRpcRequest): Promise<Json> {\n    return this.#provider.request({\n      method: 'wallet_invokeKeyring',\n      params: {\n        snapId: this.#origin,\n        request,\n      },\n    }) as Promise<Json>;\n  }\n}\n\n/**\n * A `KeyringClient` that allows the communication with a snap through the snap\n * JSON-RPC API.\n */\nexport class KeyringSnapRpcClient extends KeyringClient {\n  /**\n   * Create a new instance of `KeyringSnapRpcClient`.\n   *\n   * @param origin - Caller's origin.\n   * @param provider - The `MetaMaskInpageProvider` instance to use.\n   */\n  constructor(origin: string, provider: MetaMaskInpageProvider) {\n    super(new SnapRpcSender(origin, provider));\n  }\n}\n"]}

package/dist/events.d.ts

@@ -2,9 +2,9 @@
  * Supported keyring events.
  */
 export declare enum KeyringEvent {
-    AccountCreated = "event:accountCreated",
-    AccountUpdated = "event:accountUpdated",
-    AccountDeleted = "event:accountDeleted",
-    RequestApproved = "event:requestApproved",
-    RequestRejected = "event:requestRejected"
+    AccountCreated = "notify:accountCreated",
+    AccountUpdated = "notify:accountUpdated",
+    AccountDeleted = "notify:accountDeleted",
+    RequestApproved = "notify:requestApproved",
+    RequestRejected = "notify:requestRejected"
 }

package/dist/events.js

@@ -7,11 +7,11 @@ exports.KeyringEvent = void 0;
 var KeyringEvent;
 (function (KeyringEvent) {
     // Account events
-    KeyringEvent["AccountCreated"] = "event:accountCreated";
-    KeyringEvent["AccountUpdated"] = "event:accountUpdated";
-    KeyringEvent["AccountDeleted"] = "event:accountDeleted";
+    KeyringEvent["AccountCreated"] = "notify:accountCreated";
+    KeyringEvent["AccountUpdated"] = "notify:accountUpdated";
+    KeyringEvent["AccountDeleted"] = "notify:accountDeleted";
     // Request events
-    KeyringEvent["RequestApproved"] = "event:requestApproved";
-    KeyringEvent["RequestRejected"] = "event:requestRejected";
+    KeyringEvent["RequestApproved"] = "notify:requestApproved";
+    KeyringEvent["RequestRejected"] = "notify:requestRejected";
 })(KeyringEvent = exports.KeyringEvent || (exports.KeyringEvent = {}));
 //# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,IAAY,YASX;AATD,WAAY,YAAY;IACtB,iBAAiB;IACjB,uDAAuC,CAAA;IACvC,uDAAuC,CAAA;IACvC,uDAAuC,CAAA;IAEvC,iBAAiB;IACjB,yDAAyC,CAAA;IACzC,yDAAyC,CAAA;AAC3C,CAAC,EATW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QASvB","sourcesContent":["/**\n * Supported keyring events.\n */\nexport enum KeyringEvent {\n  // Account events\n  AccountCreated = 'event:accountCreated',\n  AccountUpdated = 'event:accountUpdated',\n  AccountDeleted = 'event:accountDeleted',\n\n  // Request events\n  RequestApproved = 'event:requestApproved',\n  RequestRejected = 'event:requestRejected',\n}\n"]}
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,IAAY,YASX;AATD,WAAY,YAAY;IACtB,iBAAiB;IACjB,wDAAwC,CAAA;IACxC,wDAAwC,CAAA;IACxC,wDAAwC,CAAA;IAExC,iBAAiB;IACjB,0DAA0C,CAAA;IAC1C,0DAA0C,CAAA;AAC5C,CAAC,EATW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QASvB","sourcesContent":["/**\n * Supported keyring events.\n */\nexport enum KeyringEvent {\n  // Account events\n  AccountCreated = 'notify:accountCreated',\n  AccountUpdated = 'notify:accountUpdated',\n  AccountDeleted = 'notify:accountDeleted',\n\n  // Request events\n  RequestApproved = 'notify:requestApproved',\n  RequestRejected = 'notify:requestRejected',\n}\n"]}

package/dist/internal/events.d.ts

@@ -1,5 +1,5 @@
 export declare const AccountCreatedEventStruct: import("superstruct").Struct<{
-    method: "event:accountCreated";
+    method: "notify:accountCreated";
     params: {
         account: {
             type: "eip155:eoa" | "eip155:eip4337";
@@ -10,7 +10,7 @@ export declare const AccountCreatedEventStruct: import("superstruct").Struct<{
         };
     };
 }, {
-    method: import("superstruct").Struct<"event:accountCreated", "event:accountCreated">;
+    method: import("superstruct").Struct<"notify:accountCreated", "notify:accountCreated">;
     params: import("superstruct").Struct<{
         account: {
             type: "eip155:eoa" | "eip155:eip4337";
@@ -49,7 +49,7 @@ export declare const AccountCreatedEventStruct: import("superstruct").Struct<{
     }>;
 }>;
 export declare const AccountUpdatedEventStruct: import("superstruct").Struct<{
-    method: "event:accountUpdated";
+    method: "notify:accountUpdated";
     params: {
         account: {
             type: "eip155:eoa" | "eip155:eip4337";
@@ -60,7 +60,7 @@ export declare const AccountUpdatedEventStruct: import("superstruct").Struct<{
         };
     };
 }, {
-    method: import("superstruct").Struct<"event:accountUpdated", "event:accountUpdated">;
+    method: import("superstruct").Struct<"notify:accountUpdated", "notify:accountUpdated">;
     params: import("superstruct").Struct<{
         account: {
             type: "eip155:eoa" | "eip155:eip4337";
@@ -99,12 +99,12 @@ export declare const AccountUpdatedEventStruct: import("superstruct").Struct<{
     }>;
 }>;
 export declare const AccountDeletedEventStruct: import("superstruct").Struct<{
-    method: "event:accountDeleted";
+    method: "notify:accountDeleted";
     params: {
         id: string;
     };
 }, {
-    method: import("superstruct").Struct<"event:accountDeleted", "event:accountDeleted">;
+    method: import("superstruct").Struct<"notify:accountDeleted", "notify:accountDeleted">;
     params: import("superstruct").Struct<{
         id: string;
     }, {
@@ -115,13 +115,13 @@ export declare const AccountDeletedEventStruct: import("superstruct").Struct<{
     }>;
 }>;
 export declare const RequestApprovedEventStruct: import("superstruct").Struct<{
-    method: "event:requestApproved";
+    method: "notify:requestApproved";
     params: {
         id: string;
         result: import("@metamask/utils").Json;
     };
 }, {
-    method: import("superstruct").Struct<"event:requestApproved", "event:requestApproved">;
+    method: import("superstruct").Struct<"notify:requestApproved", "notify:requestApproved">;
     params: import("superstruct").Struct<{
         id: string;
         result: import("@metamask/utils").Json;
@@ -137,12 +137,12 @@ export declare const RequestApprovedEventStruct: import("superstruct").Struct<{
     }>;
 }>;
 export declare const RequestRejectedEventStruct: import("superstruct").Struct<{
-    method: "event:requestRejected";
+    method: "notify:requestRejected";
     params: {
         id: string;
     };
 }, {
-    method: import("superstruct").Struct<"event:requestRejected", "event:requestRejected">;
+    method: import("superstruct").Struct<"notify:requestRejected", "notify:requestRejected">;
     params: import("superstruct").Struct<{
         id: string;
     }, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/keyring-api",
-  "version": "0.2.7",
+  "version": "1.0.0",
   "description": "MetaMask Keyring API",
   "keywords": [
     "metamask",
@@ -25,7 +25,7 @@
     "build:clean": "rimraf dist && yarn build",
     "build:docs": "typedoc",
     "lint": "yarn lint:eslint && yarn lint:constraints && yarn lint:misc --check && yarn lint:dependencies --check && yarn lint:changelog",
-    "lint:changelog": "auto-changelog validate",
+    "lint:changelog": "auto-changelog validate --prettier",
     "lint:constraints": "yarn constraints",
     "lint:dependencies": "depcheck && yarn dedupe",
     "lint:eslint": "eslint . --cache --ext js,ts",
@@ -39,9 +39,9 @@
   },
   "dependencies": {
     "@metamask/providers": "^13.0.0",
-    "@metamask/rpc-methods": "^2.0.0",
-    "@metamask/snaps-controllers": "^2.0.0",
-    "@metamask/snaps-utils": "^2.0.0",
+    "@metamask/rpc-methods": "^3.0.0",
+    "@metamask/snaps-controllers": "^3.0.0",
+    "@metamask/snaps-utils": "^3.0.0",
     "@metamask/utils": "^8.1.0",
     "@types/uuid": "^9.0.1",
     "superstruct": "^1.0.3",