@metamask/keyring-sdk 2.0.2 → 2.1.1

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.1.1]
+
+### Changed
+
+- Bump `@metamask/keyring-utils` from `^3.3.0` to `^3.3.1` ([#546](https://github.com/MetaMask/accounts/pull/546))
+
+## [2.1.0]
+
+### Added
+
+- Add `KeyringV1Adapter` ([#543](https://github.com/MetaMask/accounts/pull/543))
+  - This adapter can be used when a keyring v2 instance has no v1 equivalent (`KeyringController` still rely on v1 logic for its vault/state management).
+
+### Changed
+
+- Bump `@metamask/keyring-utils` from `^3.2.0` to `^3.3.0` ([#544](https://github.com/MetaMask/accounts/pull/544))
+
 ## [2.0.2]
 
 ### Changed
@@ -61,7 +78,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release, extracted from `@metamask/keyring-api` ([#478](https://github.com/MetaMask/accounts/pull/478)), ([#482](https://github.com/MetaMask/accounts/pull/482))
 
-[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.0.2...HEAD
+[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.1.1...HEAD
+[2.1.1]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.1.0...@metamask/keyring-sdk@2.1.1
+[2.1.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.0.2...@metamask/keyring-sdk@2.1.0
 [2.0.2]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.0.1...@metamask/keyring-sdk@2.0.2
 [2.0.1]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@2.0.0...@metamask/keyring-sdk@2.0.1
 [2.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/keyring-sdk@1.2.0...@metamask/keyring-sdk@2.0.0

package/dist/eth/account-id.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateEthAccountId = generateEthAccountId;
+exports.generateEthAccountId = void 0;
 const eth_sig_util_1 = require("@metamask/eth-sig-util");
 const utils_1 = require("@metamask/utils");
 const sha256_1 = require("ethereum-cryptography/sha256");
@@ -24,4 +24,5 @@ function generateEthAccountId(address) {
         random: (0, sha256_1.sha256)((0, utils_1.hexToBytes)(normalized)).slice(0, 16),
     });
 }
+exports.generateEthAccountId = generateEthAccountId;
 //# sourceMappingURL=account-id.cjs.map

package/dist/eth/account-id.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"account-id.cjs","sourceRoot":"","sources":["../../src/eth/account-id.ts"],"names":[],"mappings":";;AAmBA,oDAKC;AAxBD,yDAAmD;AAEnD,2CAA6C;AAC7C,yDAAsD;AACtD,+BAAoC;AAEpC;;;;;;;;;;;;GAYG;AACH,SAAgB,oBAAoB,CAAC,OAAe;IAClD,MAAM,UAAU,GAAG,IAAA,wBAAS,EAAC,OAAO,CAAW,CAAC;IAChD,OAAO,IAAA,SAAM,EAAC;QACZ,MAAM,EAAE,IAAA,eAAM,EAAC,IAAA,kBAAU,EAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;KACpD,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { normalize } from '@metamask/eth-sig-util';\nimport type { AccountId } from '@metamask/keyring-utils';\nimport { hexToBytes } from '@metamask/utils';\nimport { sha256 } from 'ethereum-cryptography/sha256';\nimport { v4 as uuidv4 } from 'uuid';\n\n/**\n * Generates a deterministic account ID for a given Ethereum address.\n *\n * The address is first normalized (lowercased, `0x`-prefixed) so that\n * checksum-cased and lowercase variants of the same address produce the\n * same ID. The ID is then a UUID v4 derived by seeding the UUID generator\n * with the first 16 bytes of the SHA-256 hash of the normalized address\n * bytes.\n *\n * @param address - The Ethereum address (hex string) to generate the account\n * ID from.\n * @returns A deterministic UUID v4 string to use as the account ID.\n */\nexport function generateEthAccountId(address: string): AccountId {\n  const normalized = normalize(address) as string;\n  return uuidv4({\n    random: sha256(hexToBytes(normalized)).slice(0, 16),\n  });\n}\n"]}
+{"version":3,"file":"account-id.cjs","sourceRoot":"","sources":["../../src/eth/account-id.ts"],"names":[],"mappings":";;;AAAA,yDAAmD;AAEnD,2CAA6C;AAC7C,yDAAsD;AACtD,+BAAoC;AAEpC;;;;;;;;;;;;GAYG;AACH,SAAgB,oBAAoB,CAAC,OAAe;IAClD,MAAM,UAAU,GAAG,IAAA,wBAAS,EAAC,OAAO,CAAW,CAAC;IAChD,OAAO,IAAA,SAAM,EAAC;QACZ,MAAM,EAAE,IAAA,eAAM,EAAC,IAAA,kBAAU,EAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;KACpD,CAAC,CAAC;AACL,CAAC;AALD,oDAKC","sourcesContent":["import { normalize } from '@metamask/eth-sig-util';\nimport type { AccountId } from '@metamask/keyring-utils';\nimport { hexToBytes } from '@metamask/utils';\nimport { sha256 } from 'ethereum-cryptography/sha256';\nimport { v4 as uuidv4 } from 'uuid';\n\n/**\n * Generates a deterministic account ID for a given Ethereum address.\n *\n * The address is first normalized (lowercased, `0x`-prefixed) so that\n * checksum-cased and lowercase variants of the same address produce the\n * same ID. The ID is then a UUID v4 derived by seeding the UUID generator\n * with the first 16 bytes of the SHA-256 hash of the normalized address\n * bytes.\n *\n * @param address - The Ethereum address (hex string) to generate the account\n * ID from.\n * @returns A deterministic UUID v4 string to use as the account ID.\n */\nexport function generateEthAccountId(address: string): AccountId {\n  const normalized = normalize(address) as string;\n  return uuidv4({\n    random: sha256(hexToBytes(normalized)).slice(0, 16),\n  });\n}\n"]}

package/dist/mnemonic.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeMnemonic = encodeMnemonic;
+exports.encodeMnemonic = void 0;
 const english_1 = require("@metamask/scure-bip39/dist/wordlists/english.js");
 /**
  * Encodes a mnemonic as an array of bytes (UTF-8).
@@ -17,4 +17,5 @@ function encodeMnemonic(mnemonicIndicesBytes) {
     const mnemonic = mnemonicIndices.map((i) => english_1.wordlist[i]).join(' ');
     return Array.from(new TextEncoder().encode(mnemonic));
 }
+exports.encodeMnemonic = encodeMnemonic;
 //# sourceMappingURL=mnemonic.cjs.map

package/dist/mnemonic.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"mnemonic.cjs","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":";;AAQA,wCASC;AAjBD,6EAAwE;AAExE;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,oBAAgC;IAC7D,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI;IAChC,0EAA0E;IAC1E,iEAAiE;IACjE,oBAAoB;IACpB,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAC7D,CAAC;IACF,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,kBAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AACxD,CAAC","sourcesContent":["import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';\n\n/**\n * Encodes a mnemonic as an array of bytes (UTF-8).\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns An array of bytes (UTF-8) representing the mnemonic.\n */\nexport function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[] {\n  const mnemonicIndices = Array.from(\n    // Create a new `Uint8Array` to ensure we have a proper view on the buffer\n    // without having to worry about `byteOffset` and `byteLength` of\n    // the inner buffer.\n    new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer),\n  );\n  const mnemonic = mnemonicIndices.map((i) => wordlist[i]).join(' ');\n  return Array.from(new TextEncoder().encode(mnemonic));\n}\n"]}
+{"version":3,"file":"mnemonic.cjs","sourceRoot":"","sources":["../src/mnemonic.ts"],"names":[],"mappings":";;;AAAA,6EAAwE;AAExE;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,oBAAgC;IAC7D,MAAM,eAAe,GAAG,KAAK,CAAC,IAAI;IAChC,0EAA0E;IAC1E,iEAAiE;IACjE,oBAAoB;IACpB,IAAI,WAAW,CAAC,IAAI,UAAU,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAC7D,CAAC;IACF,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,kBAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AACxD,CAAC;AATD,wCASC","sourcesContent":["import { wordlist } from '@metamask/scure-bip39/dist/wordlists/english';\n\n/**\n * Encodes a mnemonic as an array of bytes (UTF-8).\n *\n * @param mnemonicIndicesBytes - An array of bytes (16-bit unsigned integers) representing the indices of the words in the mnemonic.\n * @returns An array of bytes (UTF-8) representing the mnemonic.\n */\nexport function encodeMnemonic(mnemonicIndicesBytes: Uint8Array): number[] {\n  const mnemonicIndices = Array.from(\n    // Create a new `Uint8Array` to ensure we have a proper view on the buffer\n    // without having to worry about `byteOffset` and `byteLength` of\n    // the inner buffer.\n    new Uint16Array(new Uint8Array(mnemonicIndicesBytes).buffer),\n  );\n  const mnemonic = mnemonicIndices.map((i) => wordlist[i]).join(' ');\n  return Array.from(new TextEncoder().encode(mnemonic));\n}\n"]}

package/dist/v2/index.cjs

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./keyring-v1-adapter.cjs"), exports);
 __exportStar(require("./keyring-wrapper.cjs"), exports);
 __exportStar(require("./eth/index.cjs"), exports);
 //# sourceMappingURL=index.cjs.map

package/dist/v2/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAkC;AAClC,kDAAsB","sourcesContent":["export * from './keyring-wrapper';\nexport * from './eth';\n"]}
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2DAAqC;AACrC,wDAAkC;AAClC,kDAAsB","sourcesContent":["export * from './keyring-v1-adapter';\nexport * from './keyring-wrapper';\nexport * from './eth';\n"]}

package/dist/v2/index.d.cts

@@ -1,3 +1,4 @@
+export * from "./keyring-v1-adapter.cjs";
 export * from "./keyring-wrapper.cjs";
 export * from "./eth/index.cjs";
 //# sourceMappingURL=index.d.cts.map

package/dist/v2/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,sCAAkC;AAClC,gCAAsB"}
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,yCAAqC;AACrC,sCAAkC;AAClC,gCAAsB"}

package/dist/v2/index.d.mts

@@ -1,3 +1,4 @@
+export * from "./keyring-v1-adapter.mjs";
 export * from "./keyring-wrapper.mjs";
 export * from "./eth/index.mjs";
 //# sourceMappingURL=index.d.mts.map

package/dist/v2/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,sCAAkC;AAClC,gCAAsB"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,yCAAqC;AACrC,sCAAkC;AAClC,gCAAsB"}

package/dist/v2/index.mjs

@@ -1,3 +1,4 @@
+export * from "./keyring-v1-adapter.mjs";
 export * from "./keyring-wrapper.mjs";
 export * from "./eth/index.mjs";
 //# sourceMappingURL=index.mjs.map

package/dist/v2/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,sCAAkC;AAClC,gCAAsB","sourcesContent":["export * from './keyring-wrapper';\nexport * from './eth';\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,yCAAqC;AACrC,sCAAkC;AAClC,gCAAsB","sourcesContent":["export * from './keyring-v1-adapter';\nexport * from './keyring-wrapper';\nexport * from './eth';\n"]}

package/dist/v2/keyring-v1-adapter.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _KeyringV1Adapter_inner;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyringV1Adapter = void 0;
+/**
+ * Generic adapter that wraps a v2 {@link KeyringV2} instance and exposes it
+ * through the v1 {@link BaseKeyring} interface expected by `KeyringController`.
+ *
+ * ## Why this exists
+ *
+ * `KeyringController` interacts with all keyrings via the v1 `BaseKeyring`
+ * interface — notably `getAccounts()` which must return `Promise<string[]>`
+ * (addresses). The v2 `Keyring` interface returns `Promise<KeyringAccount[]>`
+ * from `getAccounts()`, an incompatible signature.
+ *
+ * ## Architecture
+ *
+ * This class holds a v2 `Keyring` instance and exposes it via {@link unwrap}.
+ * `KeyringController` stores this adapter as the v1 keyring entry; its
+ * `KeyringV2Builder` calls `unwrap()` to retrieve the same inner instance for
+ * the v2 entry — no state duplication.
+ *
+ * ```
+ * KeyringEntry {
+ *   keyring:   KeyringV1Adapter  ← v1 face (this class)
+ *   keyringV2: InnerKeyring      ← v2 face (same instance via unwrap())
+ * }
+ * ```
+ *
+ * @typeParam InnerKeyring - The concrete v2 keyring type being wrapped.
+ *   Defaults to the base {@link KeyringV2} interface. Specifying a concrete
+ *   subtype preserves full type information through {@link unwrap}.
+ */
+class KeyringV1Adapter {
+    constructor(inner) {
+        _KeyringV1Adapter_inner.set(this, void 0);
+        __classPrivateFieldSet(this, _KeyringV1Adapter_inner, inner, "f");
+        this.type = inner.type;
+    }
+    /**
+     * Returns the inner v2 {@link KeyringV2} instance.
+     *
+     * Intended for use by `KeyringController`'s `KeyringV2Builder` so that both
+     * the v1 and v2 keyring entries in a `KeyringEntry` share the same object.
+     *
+     * @returns The inner v2 keyring instance.
+     */
+    unwrap() {
+        return __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f");
+    }
+    /**
+     * Returns the addresses of all accounts in this keyring.
+     *
+     * Adapts the v2 `getAccounts()` (which returns `KeyringAccount[]`) to the
+     * v1 `BaseKeyring` interface (`string[]`).
+     *
+     * @returns A promise resolving to the list of account addresses.
+     */
+    async getAccounts() {
+        const accounts = await __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f").getAccounts();
+        return accounts.map((account) => account.address);
+    }
+    /**
+     * Serializes the keyring state.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @returns A promise resolving to the serialized state.
+     */
+    async serialize() {
+        return __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f").serialize();
+    }
+    /**
+     * Restores keyring state from a serialized snapshot.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @param state - The serialized state to restore.
+     * @returns A promise that resolves when deserialization is complete.
+     */
+    async deserialize(state) {
+        return __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f").deserialize(state);
+    }
+}
+exports.KeyringV1Adapter = KeyringV1Adapter;
+_KeyringV1Adapter_inner = new WeakMap();
+//# sourceMappingURL=keyring-v1-adapter.cjs.map

package/dist/v2/keyring-v1-adapter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring-v1-adapter.cjs","sourceRoot":"","sources":["../../src/v2/keyring-v1-adapter.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,gBAAgB;IAU3B,YAAY,KAAmB;QAFtB,0CAAqB;QAG5B,uBAAA,IAAI,2BAAU,KAAK,MAAA,CAAC;QACpB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM;QACJ,OAAO,uBAAA,IAAI,+BAAO,CAAC;IACrB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW;QACf,MAAM,QAAQ,GAAG,MAAM,uBAAA,IAAI,+BAAO,CAAC,WAAW,EAAE,CAAC;QACjD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAuB,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,SAAS;QACb,OAAO,uBAAA,IAAI,+BAAO,CAAC,SAAS,EAAE,CAAC;IACjC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW,CAAC,KAAW;QAC3B,OAAO,uBAAA,IAAI,+BAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;CACF;AA9DD,4CA8DC","sourcesContent":["import type { KeyringAccount } from '@metamask/keyring-api';\nimport type { Keyring as KeyringV2 } from '@metamask/keyring-api/v2';\nimport type { BaseKeyring } from '@metamask/keyring-utils';\nimport type { Json } from '@metamask/utils';\n\n/**\n * Generic adapter that wraps a v2 {@link KeyringV2} instance and exposes it\n * through the v1 {@link BaseKeyring} interface expected by `KeyringController`.\n *\n * ## Why this exists\n *\n * `KeyringController` interacts with all keyrings via the v1 `BaseKeyring`\n * interface — notably `getAccounts()` which must return `Promise<string[]>`\n * (addresses). The v2 `Keyring` interface returns `Promise<KeyringAccount[]>`\n * from `getAccounts()`, an incompatible signature.\n *\n * ## Architecture\n *\n * This class holds a v2 `Keyring` instance and exposes it via {@link unwrap}.\n * `KeyringController` stores this adapter as the v1 keyring entry; its\n * `KeyringV2Builder` calls `unwrap()` to retrieve the same inner instance for\n * the v2 entry — no state duplication.\n *\n * ```\n * KeyringEntry {\n *   keyring:   KeyringV1Adapter  ← v1 face (this class)\n *   keyringV2: InnerKeyring      ← v2 face (same instance via unwrap())\n * }\n * ```\n *\n * @typeParam InnerKeyring - The concrete v2 keyring type being wrapped.\n *   Defaults to the base {@link KeyringV2} interface. Specifying a concrete\n *   subtype preserves full type information through {@link unwrap}.\n */\nexport class KeyringV1Adapter<\n  InnerKeyring extends KeyringV2 = KeyringV2,\n> implements BaseKeyring {\n  /**\n   * Keyring type identifier, mirroring the inner v2 instance's type.\n   */\n  readonly type: string;\n\n  readonly #inner: InnerKeyring;\n\n  constructor(inner: InnerKeyring) {\n    this.#inner = inner;\n    this.type = inner.type;\n  }\n\n  /**\n   * Returns the inner v2 {@link KeyringV2} instance.\n   *\n   * Intended for use by `KeyringController`'s `KeyringV2Builder` so that both\n   * the v1 and v2 keyring entries in a `KeyringEntry` share the same object.\n   *\n   * @returns The inner v2 keyring instance.\n   */\n  unwrap(): InnerKeyring {\n    return this.#inner;\n  }\n\n  /**\n   * Returns the addresses of all accounts in this keyring.\n   *\n   * Adapts the v2 `getAccounts()` (which returns `KeyringAccount[]`) to the\n   * v1 `BaseKeyring` interface (`string[]`).\n   *\n   * @returns A promise resolving to the list of account addresses.\n   */\n  async getAccounts(): Promise<string[]> {\n    const accounts = await this.#inner.getAccounts();\n    return accounts.map((account: KeyringAccount) => account.address);\n  }\n\n  /**\n   * Serializes the keyring state.\n   *\n   * Delegates to the inner v2 instance.\n   *\n   * @returns A promise resolving to the serialized state.\n   */\n  async serialize(): Promise<Json> {\n    return this.#inner.serialize();\n  }\n\n  /**\n   * Restores keyring state from a serialized snapshot.\n   *\n   * Delegates to the inner v2 instance.\n   *\n   * @param state - The serialized state to restore.\n   * @returns A promise that resolves when deserialization is complete.\n   */\n  async deserialize(state: Json): Promise<void> {\n    return this.#inner.deserialize(state);\n  }\n}\n"]}

package/dist/v2/keyring-v1-adapter.d.cts

@@ -0,0 +1,76 @@
+import type { Keyring as KeyringV2 } from "@metamask/keyring-api/v2";
+import type { BaseKeyring } from "@metamask/keyring-utils";
+import type { Json } from "@metamask/utils";
+/**
+ * Generic adapter that wraps a v2 {@link KeyringV2} instance and exposes it
+ * through the v1 {@link BaseKeyring} interface expected by `KeyringController`.
+ *
+ * ## Why this exists
+ *
+ * `KeyringController` interacts with all keyrings via the v1 `BaseKeyring`
+ * interface — notably `getAccounts()` which must return `Promise<string[]>`
+ * (addresses). The v2 `Keyring` interface returns `Promise<KeyringAccount[]>`
+ * from `getAccounts()`, an incompatible signature.
+ *
+ * ## Architecture
+ *
+ * This class holds a v2 `Keyring` instance and exposes it via {@link unwrap}.
+ * `KeyringController` stores this adapter as the v1 keyring entry; its
+ * `KeyringV2Builder` calls `unwrap()` to retrieve the same inner instance for
+ * the v2 entry — no state duplication.
+ *
+ * ```
+ * KeyringEntry {
+ *   keyring:   KeyringV1Adapter  ← v1 face (this class)
+ *   keyringV2: InnerKeyring      ← v2 face (same instance via unwrap())
+ * }
+ * ```
+ *
+ * @typeParam InnerKeyring - The concrete v2 keyring type being wrapped.
+ *   Defaults to the base {@link KeyringV2} interface. Specifying a concrete
+ *   subtype preserves full type information through {@link unwrap}.
+ */
+export declare class KeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2> implements BaseKeyring {
+    #private;
+    /**
+     * Keyring type identifier, mirroring the inner v2 instance's type.
+     */
+    readonly type: string;
+    constructor(inner: InnerKeyring);
+    /**
+     * Returns the inner v2 {@link KeyringV2} instance.
+     *
+     * Intended for use by `KeyringController`'s `KeyringV2Builder` so that both
+     * the v1 and v2 keyring entries in a `KeyringEntry` share the same object.
+     *
+     * @returns The inner v2 keyring instance.
+     */
+    unwrap(): InnerKeyring;
+    /**
+     * Returns the addresses of all accounts in this keyring.
+     *
+     * Adapts the v2 `getAccounts()` (which returns `KeyringAccount[]`) to the
+     * v1 `BaseKeyring` interface (`string[]`).
+     *
+     * @returns A promise resolving to the list of account addresses.
+     */
+    getAccounts(): Promise<string[]>;
+    /**
+     * Serializes the keyring state.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @returns A promise resolving to the serialized state.
+     */
+    serialize(): Promise<Json>;
+    /**
+     * Restores keyring state from a serialized snapshot.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @param state - The serialized state to restore.
+     * @returns A promise that resolves when deserialization is complete.
+     */
+    deserialize(state: Json): Promise<void>;
+}
+//# sourceMappingURL=keyring-v1-adapter.d.cts.map

package/dist/v2/keyring-v1-adapter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring-v1-adapter.d.cts","sourceRoot":"","sources":["../../src/v2/keyring-v1-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,IAAI,SAAS,EAAE,iCAAiC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,gCAAgC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAE,wBAAwB;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,gBAAgB,CAC3B,YAAY,SAAS,SAAS,GAAG,SAAS,CAC1C,YAAW,WAAW;;IACtB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAIV,KAAK,EAAE,YAAY;IAK/B;;;;;;;OAOG;IACH,MAAM,IAAI,YAAY;IAItB;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAKtC;;;;;;OAMG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhC;;;;;;;OAOG;IACG,WAAW,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAG9C"}

package/dist/v2/keyring-v1-adapter.d.mts

@@ -0,0 +1,76 @@
+import type { Keyring as KeyringV2 } from "@metamask/keyring-api/v2";
+import type { BaseKeyring } from "@metamask/keyring-utils";
+import type { Json } from "@metamask/utils";
+/**
+ * Generic adapter that wraps a v2 {@link KeyringV2} instance and exposes it
+ * through the v1 {@link BaseKeyring} interface expected by `KeyringController`.
+ *
+ * ## Why this exists
+ *
+ * `KeyringController` interacts with all keyrings via the v1 `BaseKeyring`
+ * interface — notably `getAccounts()` which must return `Promise<string[]>`
+ * (addresses). The v2 `Keyring` interface returns `Promise<KeyringAccount[]>`
+ * from `getAccounts()`, an incompatible signature.
+ *
+ * ## Architecture
+ *
+ * This class holds a v2 `Keyring` instance and exposes it via {@link unwrap}.
+ * `KeyringController` stores this adapter as the v1 keyring entry; its
+ * `KeyringV2Builder` calls `unwrap()` to retrieve the same inner instance for
+ * the v2 entry — no state duplication.
+ *
+ * ```
+ * KeyringEntry {
+ *   keyring:   KeyringV1Adapter  ← v1 face (this class)
+ *   keyringV2: InnerKeyring      ← v2 face (same instance via unwrap())
+ * }
+ * ```
+ *
+ * @typeParam InnerKeyring - The concrete v2 keyring type being wrapped.
+ *   Defaults to the base {@link KeyringV2} interface. Specifying a concrete
+ *   subtype preserves full type information through {@link unwrap}.
+ */
+export declare class KeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2> implements BaseKeyring {
+    #private;
+    /**
+     * Keyring type identifier, mirroring the inner v2 instance's type.
+     */
+    readonly type: string;
+    constructor(inner: InnerKeyring);
+    /**
+     * Returns the inner v2 {@link KeyringV2} instance.
+     *
+     * Intended for use by `KeyringController`'s `KeyringV2Builder` so that both
+     * the v1 and v2 keyring entries in a `KeyringEntry` share the same object.
+     *
+     * @returns The inner v2 keyring instance.
+     */
+    unwrap(): InnerKeyring;
+    /**
+     * Returns the addresses of all accounts in this keyring.
+     *
+     * Adapts the v2 `getAccounts()` (which returns `KeyringAccount[]`) to the
+     * v1 `BaseKeyring` interface (`string[]`).
+     *
+     * @returns A promise resolving to the list of account addresses.
+     */
+    getAccounts(): Promise<string[]>;
+    /**
+     * Serializes the keyring state.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @returns A promise resolving to the serialized state.
+     */
+    serialize(): Promise<Json>;
+    /**
+     * Restores keyring state from a serialized snapshot.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @param state - The serialized state to restore.
+     * @returns A promise that resolves when deserialization is complete.
+     */
+    deserialize(state: Json): Promise<void>;
+}
+//# sourceMappingURL=keyring-v1-adapter.d.mts.map

package/dist/v2/keyring-v1-adapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring-v1-adapter.d.mts","sourceRoot":"","sources":["../../src/v2/keyring-v1-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,IAAI,SAAS,EAAE,iCAAiC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,gCAAgC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAE,wBAAwB;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,gBAAgB,CAC3B,YAAY,SAAS,SAAS,GAAG,SAAS,CAC1C,YAAW,WAAW;;IACtB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAIV,KAAK,EAAE,YAAY;IAK/B;;;;;;;OAOG;IACH,MAAM,IAAI,YAAY;IAItB;;;;;;;OAOG;IACG,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAKtC;;;;;;OAMG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAIhC;;;;;;;OAOG;IACG,WAAW,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAG9C"}

package/dist/v2/keyring-v1-adapter.mjs

@@ -0,0 +1,94 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _KeyringV1Adapter_inner;
+/**
+ * Generic adapter that wraps a v2 {@link KeyringV2} instance and exposes it
+ * through the v1 {@link BaseKeyring} interface expected by `KeyringController`.
+ *
+ * ## Why this exists
+ *
+ * `KeyringController` interacts with all keyrings via the v1 `BaseKeyring`
+ * interface — notably `getAccounts()` which must return `Promise<string[]>`
+ * (addresses). The v2 `Keyring` interface returns `Promise<KeyringAccount[]>`
+ * from `getAccounts()`, an incompatible signature.
+ *
+ * ## Architecture
+ *
+ * This class holds a v2 `Keyring` instance and exposes it via {@link unwrap}.
+ * `KeyringController` stores this adapter as the v1 keyring entry; its
+ * `KeyringV2Builder` calls `unwrap()` to retrieve the same inner instance for
+ * the v2 entry — no state duplication.
+ *
+ * ```
+ * KeyringEntry {
+ *   keyring:   KeyringV1Adapter  ← v1 face (this class)
+ *   keyringV2: InnerKeyring      ← v2 face (same instance via unwrap())
+ * }
+ * ```
+ *
+ * @typeParam InnerKeyring - The concrete v2 keyring type being wrapped.
+ *   Defaults to the base {@link KeyringV2} interface. Specifying a concrete
+ *   subtype preserves full type information through {@link unwrap}.
+ */
+export class KeyringV1Adapter {
+    constructor(inner) {
+        _KeyringV1Adapter_inner.set(this, void 0);
+        __classPrivateFieldSet(this, _KeyringV1Adapter_inner, inner, "f");
+        this.type = inner.type;
+    }
+    /**
+     * Returns the inner v2 {@link KeyringV2} instance.
+     *
+     * Intended for use by `KeyringController`'s `KeyringV2Builder` so that both
+     * the v1 and v2 keyring entries in a `KeyringEntry` share the same object.
+     *
+     * @returns The inner v2 keyring instance.
+     */
+    unwrap() {
+        return __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f");
+    }
+    /**
+     * Returns the addresses of all accounts in this keyring.
+     *
+     * Adapts the v2 `getAccounts()` (which returns `KeyringAccount[]`) to the
+     * v1 `BaseKeyring` interface (`string[]`).
+     *
+     * @returns A promise resolving to the list of account addresses.
+     */
+    async getAccounts() {
+        const accounts = await __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f").getAccounts();
+        return accounts.map((account) => account.address);
+    }
+    /**
+     * Serializes the keyring state.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @returns A promise resolving to the serialized state.
+     */
+    async serialize() {
+        return __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f").serialize();
+    }
+    /**
+     * Restores keyring state from a serialized snapshot.
+     *
+     * Delegates to the inner v2 instance.
+     *
+     * @param state - The serialized state to restore.
+     * @returns A promise that resolves when deserialization is complete.
+     */
+    async deserialize(state) {
+        return __classPrivateFieldGet(this, _KeyringV1Adapter_inner, "f").deserialize(state);
+    }
+}
+_KeyringV1Adapter_inner = new WeakMap();
+//# sourceMappingURL=keyring-v1-adapter.mjs.map

package/dist/v2/keyring-v1-adapter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyring-v1-adapter.mjs","sourceRoot":"","sources":["../../src/v2/keyring-v1-adapter.ts"],"names":[],"mappings":";;;;;;;;;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,gBAAgB;IAU3B,YAAY,KAAmB;QAFtB,0CAAqB;QAG5B,uBAAA,IAAI,2BAAU,KAAK,MAAA,CAAC;QACpB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM;QACJ,OAAO,uBAAA,IAAI,+BAAO,CAAC;IACrB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW;QACf,MAAM,QAAQ,GAAG,MAAM,uBAAA,IAAI,+BAAO,CAAC,WAAW,EAAE,CAAC;QACjD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAuB,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACpE,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,SAAS;QACb,OAAO,uBAAA,IAAI,+BAAO,CAAC,SAAS,EAAE,CAAC;IACjC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW,CAAC,KAAW;QAC3B,OAAO,uBAAA,IAAI,+BAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;CACF","sourcesContent":["import type { KeyringAccount } from '@metamask/keyring-api';\nimport type { Keyring as KeyringV2 } from '@metamask/keyring-api/v2';\nimport type { BaseKeyring } from '@metamask/keyring-utils';\nimport type { Json } from '@metamask/utils';\n\n/**\n * Generic adapter that wraps a v2 {@link KeyringV2} instance and exposes it\n * through the v1 {@link BaseKeyring} interface expected by `KeyringController`.\n *\n * ## Why this exists\n *\n * `KeyringController` interacts with all keyrings via the v1 `BaseKeyring`\n * interface — notably `getAccounts()` which must return `Promise<string[]>`\n * (addresses). The v2 `Keyring` interface returns `Promise<KeyringAccount[]>`\n * from `getAccounts()`, an incompatible signature.\n *\n * ## Architecture\n *\n * This class holds a v2 `Keyring` instance and exposes it via {@link unwrap}.\n * `KeyringController` stores this adapter as the v1 keyring entry; its\n * `KeyringV2Builder` calls `unwrap()` to retrieve the same inner instance for\n * the v2 entry — no state duplication.\n *\n * ```\n * KeyringEntry {\n *   keyring:   KeyringV1Adapter  ← v1 face (this class)\n *   keyringV2: InnerKeyring      ← v2 face (same instance via unwrap())\n * }\n * ```\n *\n * @typeParam InnerKeyring - The concrete v2 keyring type being wrapped.\n *   Defaults to the base {@link KeyringV2} interface. Specifying a concrete\n *   subtype preserves full type information through {@link unwrap}.\n */\nexport class KeyringV1Adapter<\n  InnerKeyring extends KeyringV2 = KeyringV2,\n> implements BaseKeyring {\n  /**\n   * Keyring type identifier, mirroring the inner v2 instance's type.\n   */\n  readonly type: string;\n\n  readonly #inner: InnerKeyring;\n\n  constructor(inner: InnerKeyring) {\n    this.#inner = inner;\n    this.type = inner.type;\n  }\n\n  /**\n   * Returns the inner v2 {@link KeyringV2} instance.\n   *\n   * Intended for use by `KeyringController`'s `KeyringV2Builder` so that both\n   * the v1 and v2 keyring entries in a `KeyringEntry` share the same object.\n   *\n   * @returns The inner v2 keyring instance.\n   */\n  unwrap(): InnerKeyring {\n    return this.#inner;\n  }\n\n  /**\n   * Returns the addresses of all accounts in this keyring.\n   *\n   * Adapts the v2 `getAccounts()` (which returns `KeyringAccount[]`) to the\n   * v1 `BaseKeyring` interface (`string[]`).\n   *\n   * @returns A promise resolving to the list of account addresses.\n   */\n  async getAccounts(): Promise<string[]> {\n    const accounts = await this.#inner.getAccounts();\n    return accounts.map((account: KeyringAccount) => account.address);\n  }\n\n  /**\n   * Serializes the keyring state.\n   *\n   * Delegates to the inner v2 instance.\n   *\n   * @returns A promise resolving to the serialized state.\n   */\n  async serialize(): Promise<Json> {\n    return this.#inner.serialize();\n  }\n\n  /**\n   * Restores keyring state from a serialized snapshot.\n   *\n   * Delegates to the inner v2 instance.\n   *\n   * @param state - The serialized state to restore.\n   * @returns A promise that resolves when deserialization is complete.\n   */\n  async deserialize(state: Json): Promise<void> {\n    return this.#inner.deserialize(state);\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/keyring-sdk",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "description": "MetaMask Keyring SDK",
   "keywords": [
     "keyring",
@@ -69,7 +69,7 @@
     "@ethereumjs/tx": "^5.4.0",
     "@metamask/eth-sig-util": "^8.2.0",
     "@metamask/keyring-api": "^23.1.0",
-    "@metamask/keyring-utils": "^3.2.0",
+    "@metamask/keyring-utils": "^3.3.1",
     "@metamask/scure-bip39": "^2.1.1",
     "@metamask/superstruct": "^3.1.0",
     "@metamask/utils": "^11.11.0",
@@ -94,7 +94,7 @@
     "ts-node": "^10.9.2",
     "tsd": "^0.31.0",
     "typedoc": "^0.25.13",
-    "typescript": "~5.6.3"
+    "typescript": "~5.3.3"
   },
   "tsd": {
     "compilerOptions": {