@metamask/keyring-sdk 4.0.0 → 4.2.0

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,8BAA0B;AAC1B,gCAAsB"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,qCAAiC;AACjC,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,8BAA0B;AAC1B,sCAAkC;AAClC,gCAAsB"}

package/dist/index.mjs

@@ -1,6 +1,8 @@
+export * from "./atomic-keyring.mjs";
 export * from "./keyring-account-registry.mjs";
 export * from "./migration.mjs";
 export * from "./mnemonic.mjs";
 export * from "./entropy.mjs";
+export * from "./read-write-lock.mjs";
 export * from "./eth/index.mjs";
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,8BAA0B;AAC1B,gCAAsB","sourcesContent":["export * from './keyring-account-registry';\nexport * from './migration';\nexport * from './mnemonic';\nexport * from './entropy';\nexport * from './eth';\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,qCAAiC;AACjC,+CAA2C;AAC3C,gCAA4B;AAC5B,+BAA2B;AAC3B,8BAA0B;AAC1B,sCAAkC;AAClC,gCAAsB","sourcesContent":["export * from './atomic-keyring';\nexport * from './keyring-account-registry';\nexport * from './migration';\nexport * from './mnemonic';\nexport * from './entropy';\nexport * from './read-write-lock';\nexport * from './eth';\n"]}

package/dist/read-write-lock.cjs

@@ -0,0 +1,150 @@
+"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 _ReadWriteLock_instances, _ReadWriteLock_readerCount, _ReadWriteLock_writerActive, _ReadWriteLock_waiters, _ReadWriteLock_priority, _ReadWriteLock_withLock, _ReadWriteLock_hasWaiters, _ReadWriteLock_isReading, _ReadWriteLock_isWriting, _ReadWriteLock_acquire, _ReadWriteLock_grant, _ReadWriteLock_release, _ReadWriteLock_drain;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadWriteLock = void 0;
+/**
+ * A read-write lock: multiple readers may hold the lock simultaneously,
+ * while writers hold it exclusively.
+ *
+ * Grant order is first-in-first-out, and the lock is write-preferring by
+ * default: a pending writer blocks new readers, and consecutive queued
+ * readers are granted together once the lock turns over to them. Set the
+ * `priority` option to `'read'` to let new readers join active readers even
+ * while a writer is queued — better read latency, at the cost that
+ * continuous reads can starve a queued writer. The lock is always released
+ * when the callback settles, whether it resolves or throws.
+ */
+class ReadWriteLock {
+    /**
+     * @param options - Lock options.
+     * @param options.priority - Which mode takes priority when both are
+     * contended. Defaults to `'write'`.
+     */
+    constructor(options = {}) {
+        _ReadWriteLock_instances.add(this);
+        _ReadWriteLock_readerCount.set(this, 0);
+        _ReadWriteLock_writerActive.set(this, false);
+        _ReadWriteLock_waiters.set(this, []);
+        _ReadWriteLock_priority.set(this, void 0);
+        __classPrivateFieldSet(this, _ReadWriteLock_priority, options.priority ?? 'write', "f");
+    }
+    /**
+     * Run a read operation — parallel with other readers, exclusive with
+     * writers. New readers queue behind any pending writer.
+     *
+     * @param fn - The operation to run while holding the read lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    async withReadLock(fn) {
+        return __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_withLock).call(this, 'read', fn);
+    }
+    /**
+     * Run a write operation — exclusive with readers and other writers.
+     *
+     * @param fn - The operation to run while holding the write lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    async withWriteLock(fn) {
+        return __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_withLock).call(this, 'write', fn);
+    }
+}
+exports.ReadWriteLock = ReadWriteLock;
+_ReadWriteLock_readerCount = new WeakMap(), _ReadWriteLock_writerActive = new WeakMap(), _ReadWriteLock_waiters = new WeakMap(), _ReadWriteLock_priority = new WeakMap(), _ReadWriteLock_instances = new WeakSet(), _ReadWriteLock_withLock = 
+/**
+ * Acquire the lock in the given mode, run the operation, and release the
+ * lock — including on a throw, so the lock can never leak.
+ *
+ * @param mode - The mode in which to hold the lock.
+ * @param fn - The operation to run while holding the lock.
+ * @returns Whatever `fn` resolves to.
+ */
+async function _ReadWriteLock_withLock(mode, fn) {
+    await __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_acquire).call(this, mode);
+    try {
+        return await fn();
+    }
+    finally {
+        __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_release).call(this, mode);
+    }
+}, _ReadWriteLock_hasWaiters = function _ReadWriteLock_hasWaiters() {
+    return __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").length > 0;
+}, _ReadWriteLock_isReading = function _ReadWriteLock_isReading() {
+    return __classPrivateFieldGet(this, _ReadWriteLock_readerCount, "f") > 0;
+}, _ReadWriteLock_isWriting = function _ReadWriteLock_isWriting() {
+    return __classPrivateFieldGet(this, _ReadWriteLock_writerActive, "f");
+}, _ReadWriteLock_acquire = 
+/**
+ * Acquire the lock in the given mode, queuing when it cannot be granted
+ * immediately.
+ *
+ * @param mode - The mode to acquire.
+ * @returns A promise that resolves once the lock is held.
+ */
+async function _ReadWriteLock_acquire(mode) {
+    return new Promise((resolve) => {
+        // Writing is exclusive, so we cannot acquire the lock if a writer is active.
+        const blockedByWriter = __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isWriting).call(this);
+        // Writing is exclusive with readers, so we cannot acquire the lock if any reader is active.
+        const blockedByReaders = mode === 'write' && __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isReading).call(this);
+        // We cannot acquire the lock for reading if there are waiters, unless priority is 'read'.
+        const blockedByWriterPriority = mode === 'read' && __classPrivateFieldGet(this, _ReadWriteLock_priority, "f") === 'write' && __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_hasWaiters).call(this); // We might have pending write requests in the queue.
+        const acquire = !(blockedByWriter ||
+            blockedByReaders ||
+            blockedByWriterPriority);
+        if (acquire) {
+            __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_grant).call(this, mode);
+            resolve();
+        }
+        else {
+            // We cannot grant the lock immediately, so we queue the waiter.
+            __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").push({ mode, resolve });
+        }
+    });
+}, _ReadWriteLock_grant = function _ReadWriteLock_grant(mode) {
+    if (mode === 'read') {
+        __classPrivateFieldSet(this, _ReadWriteLock_readerCount, __classPrivateFieldGet(this, _ReadWriteLock_readerCount, "f") + 1, "f");
+    }
+    else {
+        __classPrivateFieldSet(this, _ReadWriteLock_writerActive, true, "f");
+    }
+}, _ReadWriteLock_release = function _ReadWriteLock_release(mode) {
+    if (mode === 'read') {
+        __classPrivateFieldSet(this, _ReadWriteLock_readerCount, __classPrivateFieldGet(this, _ReadWriteLock_readerCount, "f") - 1, "f");
+    }
+    else {
+        __classPrivateFieldSet(this, _ReadWriteLock_writerActive, false, "f");
+    }
+    __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_drain).call(this);
+}, _ReadWriteLock_drain = function _ReadWriteLock_drain() {
+    let waiter = __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").shift();
+    while (waiter !== undefined) {
+        // Writing is exclusive, so we cannot acquire the lock if a writer is active.
+        const blockedByWriter = __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isWriting).call(this);
+        // Reading blocks a writer, so we cannot acquire the lock for writing if any reader is active.
+        const blockedByReaders = waiter.mode === 'write' && __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isReading).call(this);
+        const acquire = !(blockedByWriter || blockedByReaders);
+        if (acquire) {
+            // Grant the front waiter and continue with the next one, so consecutive queued readers are granted together.
+            __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_grant).call(this, waiter.mode);
+            waiter.resolve();
+            waiter = __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").shift();
+        }
+        else {
+            // The waiter is blocked by an active holder; put it back at the front and stop.
+            __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").unshift(waiter);
+            return;
+        }
+    }
+};
+//# sourceMappingURL=read-write-lock.cjs.map

package/dist/read-write-lock.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-write-lock.cjs","sourceRoot":"","sources":["../src/read-write-lock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A mode in which the lock can be held: shared (`'read'`) or exclusive\n * (`'write'`).\n */\ntype LockMode = 'read' | 'write';\n\n/**\n * A queued lock-acquisition request.\n */\ntype LockWaiter = {\n  /** The mode being acquired. */\n  mode: LockMode;\n  /** Resolves once the lock has been granted. */\n  resolve: () => void;\n};\n\n/**\n * Which mode a {@link ReadWriteLock} prioritizes when both are contended.\n */\nexport type ReadWriteLockPriority = 'read' | 'write';\n\n/**\n * Options for constructing a {@link ReadWriteLock}.\n */\nexport type ReadWriteLockOptions = {\n  /**\n   * Which mode takes priority when both are contended. Defaults to\n   * `'write'`.\n   *\n   * - `'write'`: a pending writer blocks new readers, so a steady stream of\n   * reads cannot starve a long write.\n   * - `'read'`: new readers join active readers even while a writer is\n   * queued, for better read latency — at the cost that a continuous stream\n   * of reads can starve a queued writer.\n   */\n  priority?: ReadWriteLockPriority;\n};\n\n/**\n * A read-write lock: multiple readers may hold the lock simultaneously,\n * while writers hold it exclusively.\n *\n * Grant order is first-in-first-out, and the lock is write-preferring by\n * default: a pending writer blocks new readers, and consecutive queued\n * readers are granted together once the lock turns over to them. Set the\n * `priority` option to `'read'` to let new readers join active readers even\n * while a writer is queued — better read latency, at the cost that\n * continuous reads can starve a queued writer. The lock is always released\n * when the callback settles, whether it resolves or throws.\n */\nexport class ReadWriteLock {\n  #readerCount: number = 0;\n\n  #writerActive: boolean = false;\n\n  readonly #waiters: LockWaiter[] = [];\n\n  readonly #priority: ReadWriteLockPriority;\n\n  /**\n   * @param options - Lock options.\n   * @param options.priority - Which mode takes priority when both are\n   * contended. Defaults to `'write'`.\n   */\n  constructor(options: ReadWriteLockOptions = {}) {\n    this.#priority = options.priority ?? 'write';\n  }\n\n  /**\n   * Run a read operation — parallel with other readers, exclusive with\n   * writers. New readers queue behind any pending writer.\n   *\n   * @param fn - The operation to run while holding the read lock.\n   * @returns Whatever `fn` resolves to.\n   */\n  async withReadLock<Result>(fn: () => Promise<Result>): Promise<Result> {\n    return this.#withLock('read', fn);\n  }\n\n  /**\n   * Run a write operation — exclusive with readers and other writers.\n   *\n   * @param fn - The operation to run while holding the write lock.\n   * @returns Whatever `fn` resolves to.\n   */\n  async withWriteLock<Result>(fn: () => Promise<Result>): Promise<Result> {\n    return this.#withLock('write', fn);\n  }\n\n  /**\n   * Acquire the lock in the given mode, run the operation, and release the\n   * lock — including on a throw, so the lock can never leak.\n   *\n   * @param mode - The mode in which to hold the lock.\n   * @param fn - The operation to run while holding the lock.\n   * @returns Whatever `fn` resolves to.\n   */\n  async #withLock<Result>(\n    mode: LockMode,\n    fn: () => Promise<Result>,\n  ): Promise<Result> {\n    await this.#acquire(mode);\n    try {\n      return await fn();\n    } finally {\n      this.#release(mode);\n    }\n  }\n\n  /**\n   * Whether any acquisition request is queued, waiting for the lock to turn\n   * over to it. A queued waiter always blocks newcomers, which keeps the\n   * grant order first-in-first-out.\n   *\n   * @returns Whether any acquisition request is queued.\n   */\n  #hasWaiters(): boolean {\n    return this.#waiters.length > 0;\n  }\n\n  /**\n   * Whether the lock is currently held for reading. Readers hold the lock\n   * in parallel, so this does not mean an exclusive hold.\n   *\n   * @returns Whether any reader is active.\n   */\n  #isReading(): boolean {\n    return this.#readerCount > 0;\n  }\n\n  /**\n   * Whether the lock is currently held for writing. A writer holds the lock\n   * exclusively: while writing, no other holder — reader or writer — can\n   * be active.\n   *\n   * @returns Whether a writer is active.\n   */\n  #isWriting(): boolean {\n    return this.#writerActive;\n  }\n\n  /**\n   * Acquire the lock in the given mode, queuing when it cannot be granted\n   * immediately.\n   *\n   * @param mode - The mode to acquire.\n   * @returns A promise that resolves once the lock is held.\n   */\n  async #acquire(mode: LockMode): Promise<void> {\n    return new Promise<void>((resolve) => {\n      // Writing is exclusive, so we cannot acquire the lock if a writer is active.\n      const blockedByWriter = this.#isWriting();\n      // Writing is exclusive with readers, so we cannot acquire the lock if any reader is active.\n      const blockedByReaders = mode === 'write' && this.#isReading();\n      // We cannot acquire the lock for reading if there are waiters, unless priority is 'read'.\n      const blockedByWriterPriority =\n        mode === 'read' && this.#priority === 'write' && this.#hasWaiters(); // We might have pending write requests in the queue.\n\n      const acquire = !(\n        blockedByWriter ||\n        blockedByReaders ||\n        blockedByWriterPriority\n      );\n\n      if (acquire) {\n        this.#grant(mode);\n        resolve();\n      } else {\n        // We cannot grant the lock immediately, so we queue the waiter.\n        this.#waiters.push({ mode, resolve });\n      }\n    });\n  }\n\n  /**\n   * Grant the lock in the given mode. Only called when the grant is legal.\n   *\n   * @param mode - The mode to grant.\n   */\n  #grant(mode: LockMode): void {\n    if (mode === 'read') {\n      this.#readerCount += 1;\n    } else {\n      this.#writerActive = true;\n    }\n  }\n\n  /**\n   * Release the lock in the given mode, then grant queued waiters in order.\n   *\n   * @param mode - The mode being released.\n   */\n  #release(mode: LockMode): void {\n    if (mode === 'read') {\n      this.#readerCount -= 1;\n    } else {\n      this.#writerActive = false;\n    }\n    this.#drain();\n  }\n\n  /**\n   * Grant queued waiters, in order, while the front of the queue can be\n   * granted. Consecutive queued readers are granted together; a granted\n   * writer blocks everything behind it. Unlike a newcomer, the front\n   * waiter is never blocked by queued waiters — everyone behind it\n   * arrived later — so only active holders block a grant here.\n   */\n  #drain(): void {\n    let waiter: LockWaiter | undefined = this.#waiters.shift();\n    while (waiter !== undefined) {\n      // Writing is exclusive, so we cannot acquire the lock if a writer is active.\n      const blockedByWriter = this.#isWriting();\n      // Reading blocks a writer, so we cannot acquire the lock for writing if any reader is active.\n      const blockedByReaders = waiter.mode === 'write' && this.#isReading();\n\n      const acquire = !(blockedByWriter || blockedByReaders);\n\n      if (acquire) {\n        // Grant the front waiter and continue with the next one, so consecutive queued readers are granted together.\n        this.#grant(waiter.mode);\n        waiter.resolve();\n        waiter = this.#waiters.shift();\n      } else {\n        // The waiter is blocked by an active holder; put it back at the front and stop.\n        this.#waiters.unshift(waiter);\n        return;\n      }\n    }\n  }\n}\n"]}

package/dist/read-write-lock.d.cts

@@ -0,0 +1,57 @@
+/**
+ * Which mode a {@link ReadWriteLock} prioritizes when both are contended.
+ */
+export type ReadWriteLockPriority = 'read' | 'write';
+/**
+ * Options for constructing a {@link ReadWriteLock}.
+ */
+export type ReadWriteLockOptions = {
+    /**
+     * Which mode takes priority when both are contended. Defaults to
+     * `'write'`.
+     *
+     * - `'write'`: a pending writer blocks new readers, so a steady stream of
+     * reads cannot starve a long write.
+     * - `'read'`: new readers join active readers even while a writer is
+     * queued, for better read latency — at the cost that a continuous stream
+     * of reads can starve a queued writer.
+     */
+    priority?: ReadWriteLockPriority;
+};
+/**
+ * A read-write lock: multiple readers may hold the lock simultaneously,
+ * while writers hold it exclusively.
+ *
+ * Grant order is first-in-first-out, and the lock is write-preferring by
+ * default: a pending writer blocks new readers, and consecutive queued
+ * readers are granted together once the lock turns over to them. Set the
+ * `priority` option to `'read'` to let new readers join active readers even
+ * while a writer is queued — better read latency, at the cost that
+ * continuous reads can starve a queued writer. The lock is always released
+ * when the callback settles, whether it resolves or throws.
+ */
+export declare class ReadWriteLock {
+    #private;
+    /**
+     * @param options - Lock options.
+     * @param options.priority - Which mode takes priority when both are
+     * contended. Defaults to `'write'`.
+     */
+    constructor(options?: ReadWriteLockOptions);
+    /**
+     * Run a read operation — parallel with other readers, exclusive with
+     * writers. New readers queue behind any pending writer.
+     *
+     * @param fn - The operation to run while holding the read lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    withReadLock<Result>(fn: () => Promise<Result>): Promise<Result>;
+    /**
+     * Run a write operation — exclusive with readers and other writers.
+     *
+     * @param fn - The operation to run while holding the write lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    withWriteLock<Result>(fn: () => Promise<Result>): Promise<Result>;
+}
+//# sourceMappingURL=read-write-lock.d.cts.map

package/dist/read-write-lock.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-write-lock.d.cts","sourceRoot":"","sources":["../src/read-write-lock.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;;IASxB;;;;OAIG;gBACS,OAAO,GAAE,oBAAyB;IAI9C;;;;;;OAMG;IACG,YAAY,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAItE;;;;;OAKG;IACG,aAAa,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAiJxE"}

package/dist/read-write-lock.d.mts

@@ -0,0 +1,57 @@
+/**
+ * Which mode a {@link ReadWriteLock} prioritizes when both are contended.
+ */
+export type ReadWriteLockPriority = 'read' | 'write';
+/**
+ * Options for constructing a {@link ReadWriteLock}.
+ */
+export type ReadWriteLockOptions = {
+    /**
+     * Which mode takes priority when both are contended. Defaults to
+     * `'write'`.
+     *
+     * - `'write'`: a pending writer blocks new readers, so a steady stream of
+     * reads cannot starve a long write.
+     * - `'read'`: new readers join active readers even while a writer is
+     * queued, for better read latency — at the cost that a continuous stream
+     * of reads can starve a queued writer.
+     */
+    priority?: ReadWriteLockPriority;
+};
+/**
+ * A read-write lock: multiple readers may hold the lock simultaneously,
+ * while writers hold it exclusively.
+ *
+ * Grant order is first-in-first-out, and the lock is write-preferring by
+ * default: a pending writer blocks new readers, and consecutive queued
+ * readers are granted together once the lock turns over to them. Set the
+ * `priority` option to `'read'` to let new readers join active readers even
+ * while a writer is queued — better read latency, at the cost that
+ * continuous reads can starve a queued writer. The lock is always released
+ * when the callback settles, whether it resolves or throws.
+ */
+export declare class ReadWriteLock {
+    #private;
+    /**
+     * @param options - Lock options.
+     * @param options.priority - Which mode takes priority when both are
+     * contended. Defaults to `'write'`.
+     */
+    constructor(options?: ReadWriteLockOptions);
+    /**
+     * Run a read operation — parallel with other readers, exclusive with
+     * writers. New readers queue behind any pending writer.
+     *
+     * @param fn - The operation to run while holding the read lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    withReadLock<Result>(fn: () => Promise<Result>): Promise<Result>;
+    /**
+     * Run a write operation — exclusive with readers and other writers.
+     *
+     * @param fn - The operation to run while holding the write lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    withWriteLock<Result>(fn: () => Promise<Result>): Promise<Result>;
+}
+//# sourceMappingURL=read-write-lock.d.mts.map

package/dist/read-write-lock.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-write-lock.d.mts","sourceRoot":"","sources":["../src/read-write-lock.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;;IASxB;;;;OAIG;gBACS,OAAO,GAAE,oBAAyB;IAI9C;;;;;;OAMG;IACG,YAAY,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAItE;;;;;OAKG;IACG,aAAa,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAiJxE"}

package/dist/read-write-lock.mjs

@@ -0,0 +1,146 @@
+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 _ReadWriteLock_instances, _ReadWriteLock_readerCount, _ReadWriteLock_writerActive, _ReadWriteLock_waiters, _ReadWriteLock_priority, _ReadWriteLock_withLock, _ReadWriteLock_hasWaiters, _ReadWriteLock_isReading, _ReadWriteLock_isWriting, _ReadWriteLock_acquire, _ReadWriteLock_grant, _ReadWriteLock_release, _ReadWriteLock_drain;
+/**
+ * A read-write lock: multiple readers may hold the lock simultaneously,
+ * while writers hold it exclusively.
+ *
+ * Grant order is first-in-first-out, and the lock is write-preferring by
+ * default: a pending writer blocks new readers, and consecutive queued
+ * readers are granted together once the lock turns over to them. Set the
+ * `priority` option to `'read'` to let new readers join active readers even
+ * while a writer is queued — better read latency, at the cost that
+ * continuous reads can starve a queued writer. The lock is always released
+ * when the callback settles, whether it resolves or throws.
+ */
+export class ReadWriteLock {
+    /**
+     * @param options - Lock options.
+     * @param options.priority - Which mode takes priority when both are
+     * contended. Defaults to `'write'`.
+     */
+    constructor(options = {}) {
+        _ReadWriteLock_instances.add(this);
+        _ReadWriteLock_readerCount.set(this, 0);
+        _ReadWriteLock_writerActive.set(this, false);
+        _ReadWriteLock_waiters.set(this, []);
+        _ReadWriteLock_priority.set(this, void 0);
+        __classPrivateFieldSet(this, _ReadWriteLock_priority, options.priority ?? 'write', "f");
+    }
+    /**
+     * Run a read operation — parallel with other readers, exclusive with
+     * writers. New readers queue behind any pending writer.
+     *
+     * @param fn - The operation to run while holding the read lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    async withReadLock(fn) {
+        return __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_withLock).call(this, 'read', fn);
+    }
+    /**
+     * Run a write operation — exclusive with readers and other writers.
+     *
+     * @param fn - The operation to run while holding the write lock.
+     * @returns Whatever `fn` resolves to.
+     */
+    async withWriteLock(fn) {
+        return __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_withLock).call(this, 'write', fn);
+    }
+}
+_ReadWriteLock_readerCount = new WeakMap(), _ReadWriteLock_writerActive = new WeakMap(), _ReadWriteLock_waiters = new WeakMap(), _ReadWriteLock_priority = new WeakMap(), _ReadWriteLock_instances = new WeakSet(), _ReadWriteLock_withLock = 
+/**
+ * Acquire the lock in the given mode, run the operation, and release the
+ * lock — including on a throw, so the lock can never leak.
+ *
+ * @param mode - The mode in which to hold the lock.
+ * @param fn - The operation to run while holding the lock.
+ * @returns Whatever `fn` resolves to.
+ */
+async function _ReadWriteLock_withLock(mode, fn) {
+    await __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_acquire).call(this, mode);
+    try {
+        return await fn();
+    }
+    finally {
+        __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_release).call(this, mode);
+    }
+}, _ReadWriteLock_hasWaiters = function _ReadWriteLock_hasWaiters() {
+    return __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").length > 0;
+}, _ReadWriteLock_isReading = function _ReadWriteLock_isReading() {
+    return __classPrivateFieldGet(this, _ReadWriteLock_readerCount, "f") > 0;
+}, _ReadWriteLock_isWriting = function _ReadWriteLock_isWriting() {
+    return __classPrivateFieldGet(this, _ReadWriteLock_writerActive, "f");
+}, _ReadWriteLock_acquire = 
+/**
+ * Acquire the lock in the given mode, queuing when it cannot be granted
+ * immediately.
+ *
+ * @param mode - The mode to acquire.
+ * @returns A promise that resolves once the lock is held.
+ */
+async function _ReadWriteLock_acquire(mode) {
+    return new Promise((resolve) => {
+        // Writing is exclusive, so we cannot acquire the lock if a writer is active.
+        const blockedByWriter = __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isWriting).call(this);
+        // Writing is exclusive with readers, so we cannot acquire the lock if any reader is active.
+        const blockedByReaders = mode === 'write' && __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isReading).call(this);
+        // We cannot acquire the lock for reading if there are waiters, unless priority is 'read'.
+        const blockedByWriterPriority = mode === 'read' && __classPrivateFieldGet(this, _ReadWriteLock_priority, "f") === 'write' && __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_hasWaiters).call(this); // We might have pending write requests in the queue.
+        const acquire = !(blockedByWriter ||
+            blockedByReaders ||
+            blockedByWriterPriority);
+        if (acquire) {
+            __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_grant).call(this, mode);
+            resolve();
+        }
+        else {
+            // We cannot grant the lock immediately, so we queue the waiter.
+            __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").push({ mode, resolve });
+        }
+    });
+}, _ReadWriteLock_grant = function _ReadWriteLock_grant(mode) {
+    if (mode === 'read') {
+        __classPrivateFieldSet(this, _ReadWriteLock_readerCount, __classPrivateFieldGet(this, _ReadWriteLock_readerCount, "f") + 1, "f");
+    }
+    else {
+        __classPrivateFieldSet(this, _ReadWriteLock_writerActive, true, "f");
+    }
+}, _ReadWriteLock_release = function _ReadWriteLock_release(mode) {
+    if (mode === 'read') {
+        __classPrivateFieldSet(this, _ReadWriteLock_readerCount, __classPrivateFieldGet(this, _ReadWriteLock_readerCount, "f") - 1, "f");
+    }
+    else {
+        __classPrivateFieldSet(this, _ReadWriteLock_writerActive, false, "f");
+    }
+    __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_drain).call(this);
+}, _ReadWriteLock_drain = function _ReadWriteLock_drain() {
+    let waiter = __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").shift();
+    while (waiter !== undefined) {
+        // Writing is exclusive, so we cannot acquire the lock if a writer is active.
+        const blockedByWriter = __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isWriting).call(this);
+        // Reading blocks a writer, so we cannot acquire the lock for writing if any reader is active.
+        const blockedByReaders = waiter.mode === 'write' && __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_isReading).call(this);
+        const acquire = !(blockedByWriter || blockedByReaders);
+        if (acquire) {
+            // Grant the front waiter and continue with the next one, so consecutive queued readers are granted together.
+            __classPrivateFieldGet(this, _ReadWriteLock_instances, "m", _ReadWriteLock_grant).call(this, waiter.mode);
+            waiter.resolve();
+            waiter = __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").shift();
+        }
+        else {
+            // The waiter is blocked by an active holder; put it back at the front and stop.
+            __classPrivateFieldGet(this, _ReadWriteLock_waiters, "f").unshift(waiter);
+            return;
+        }
+    }
+};
+//# sourceMappingURL=read-write-lock.mjs.map

package/dist/read-write-lock.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-write-lock.mjs","sourceRoot":"","sources":["../src/read-write-lock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A mode in which the lock can be held: shared (`'read'`) or exclusive\n * (`'write'`).\n */\ntype LockMode = 'read' | 'write';\n\n/**\n * A queued lock-acquisition request.\n */\ntype LockWaiter = {\n  /** The mode being acquired. */\n  mode: LockMode;\n  /** Resolves once the lock has been granted. */\n  resolve: () => void;\n};\n\n/**\n * Which mode a {@link ReadWriteLock} prioritizes when both are contended.\n */\nexport type ReadWriteLockPriority = 'read' | 'write';\n\n/**\n * Options for constructing a {@link ReadWriteLock}.\n */\nexport type ReadWriteLockOptions = {\n  /**\n   * Which mode takes priority when both are contended. Defaults to\n   * `'write'`.\n   *\n   * - `'write'`: a pending writer blocks new readers, so a steady stream of\n   * reads cannot starve a long write.\n   * - `'read'`: new readers join active readers even while a writer is\n   * queued, for better read latency — at the cost that a continuous stream\n   * of reads can starve a queued writer.\n   */\n  priority?: ReadWriteLockPriority;\n};\n\n/**\n * A read-write lock: multiple readers may hold the lock simultaneously,\n * while writers hold it exclusively.\n *\n * Grant order is first-in-first-out, and the lock is write-preferring by\n * default: a pending writer blocks new readers, and consecutive queued\n * readers are granted together once the lock turns over to them. Set the\n * `priority` option to `'read'` to let new readers join active readers even\n * while a writer is queued — better read latency, at the cost that\n * continuous reads can starve a queued writer. The lock is always released\n * when the callback settles, whether it resolves or throws.\n */\nexport class ReadWriteLock {\n  #readerCount: number = 0;\n\n  #writerActive: boolean = false;\n\n  readonly #waiters: LockWaiter[] = [];\n\n  readonly #priority: ReadWriteLockPriority;\n\n  /**\n   * @param options - Lock options.\n   * @param options.priority - Which mode takes priority when both are\n   * contended. Defaults to `'write'`.\n   */\n  constructor(options: ReadWriteLockOptions = {}) {\n    this.#priority = options.priority ?? 'write';\n  }\n\n  /**\n   * Run a read operation — parallel with other readers, exclusive with\n   * writers. New readers queue behind any pending writer.\n   *\n   * @param fn - The operation to run while holding the read lock.\n   * @returns Whatever `fn` resolves to.\n   */\n  async withReadLock<Result>(fn: () => Promise<Result>): Promise<Result> {\n    return this.#withLock('read', fn);\n  }\n\n  /**\n   * Run a write operation — exclusive with readers and other writers.\n   *\n   * @param fn - The operation to run while holding the write lock.\n   * @returns Whatever `fn` resolves to.\n   */\n  async withWriteLock<Result>(fn: () => Promise<Result>): Promise<Result> {\n    return this.#withLock('write', fn);\n  }\n\n  /**\n   * Acquire the lock in the given mode, run the operation, and release the\n   * lock — including on a throw, so the lock can never leak.\n   *\n   * @param mode - The mode in which to hold the lock.\n   * @param fn - The operation to run while holding the lock.\n   * @returns Whatever `fn` resolves to.\n   */\n  async #withLock<Result>(\n    mode: LockMode,\n    fn: () => Promise<Result>,\n  ): Promise<Result> {\n    await this.#acquire(mode);\n    try {\n      return await fn();\n    } finally {\n      this.#release(mode);\n    }\n  }\n\n  /**\n   * Whether any acquisition request is queued, waiting for the lock to turn\n   * over to it. A queued waiter always blocks newcomers, which keeps the\n   * grant order first-in-first-out.\n   *\n   * @returns Whether any acquisition request is queued.\n   */\n  #hasWaiters(): boolean {\n    return this.#waiters.length > 0;\n  }\n\n  /**\n   * Whether the lock is currently held for reading. Readers hold the lock\n   * in parallel, so this does not mean an exclusive hold.\n   *\n   * @returns Whether any reader is active.\n   */\n  #isReading(): boolean {\n    return this.#readerCount > 0;\n  }\n\n  /**\n   * Whether the lock is currently held for writing. A writer holds the lock\n   * exclusively: while writing, no other holder — reader or writer — can\n   * be active.\n   *\n   * @returns Whether a writer is active.\n   */\n  #isWriting(): boolean {\n    return this.#writerActive;\n  }\n\n  /**\n   * Acquire the lock in the given mode, queuing when it cannot be granted\n   * immediately.\n   *\n   * @param mode - The mode to acquire.\n   * @returns A promise that resolves once the lock is held.\n   */\n  async #acquire(mode: LockMode): Promise<void> {\n    return new Promise<void>((resolve) => {\n      // Writing is exclusive, so we cannot acquire the lock if a writer is active.\n      const blockedByWriter = this.#isWriting();\n      // Writing is exclusive with readers, so we cannot acquire the lock if any reader is active.\n      const blockedByReaders = mode === 'write' && this.#isReading();\n      // We cannot acquire the lock for reading if there are waiters, unless priority is 'read'.\n      const blockedByWriterPriority =\n        mode === 'read' && this.#priority === 'write' && this.#hasWaiters(); // We might have pending write requests in the queue.\n\n      const acquire = !(\n        blockedByWriter ||\n        blockedByReaders ||\n        blockedByWriterPriority\n      );\n\n      if (acquire) {\n        this.#grant(mode);\n        resolve();\n      } else {\n        // We cannot grant the lock immediately, so we queue the waiter.\n        this.#waiters.push({ mode, resolve });\n      }\n    });\n  }\n\n  /**\n   * Grant the lock in the given mode. Only called when the grant is legal.\n   *\n   * @param mode - The mode to grant.\n   */\n  #grant(mode: LockMode): void {\n    if (mode === 'read') {\n      this.#readerCount += 1;\n    } else {\n      this.#writerActive = true;\n    }\n  }\n\n  /**\n   * Release the lock in the given mode, then grant queued waiters in order.\n   *\n   * @param mode - The mode being released.\n   */\n  #release(mode: LockMode): void {\n    if (mode === 'read') {\n      this.#readerCount -= 1;\n    } else {\n      this.#writerActive = false;\n    }\n    this.#drain();\n  }\n\n  /**\n   * Grant queued waiters, in order, while the front of the queue can be\n   * granted. Consecutive queued readers are granted together; a granted\n   * writer blocks everything behind it. Unlike a newcomer, the front\n   * waiter is never blocked by queued waiters — everyone behind it\n   * arrived later — so only active holders block a grant here.\n   */\n  #drain(): void {\n    let waiter: LockWaiter | undefined = this.#waiters.shift();\n    while (waiter !== undefined) {\n      // Writing is exclusive, so we cannot acquire the lock if a writer is active.\n      const blockedByWriter = this.#isWriting();\n      // Reading blocks a writer, so we cannot acquire the lock for writing if any reader is active.\n      const blockedByReaders = waiter.mode === 'write' && this.#isReading();\n\n      const acquire = !(blockedByWriter || blockedByReaders);\n\n      if (acquire) {\n        // Grant the front waiter and continue with the next one, so consecutive queued readers are granted together.\n        this.#grant(waiter.mode);\n        waiter.resolve();\n        waiter = this.#waiters.shift();\n      } else {\n        // The waiter is blocked by an active holder; put it back at the front and stop.\n        this.#waiters.unshift(waiter);\n        return;\n      }\n    }\n  }\n}\n"]}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyringV1Adapter = void 0;
+exports.isKeyringV1Adapter = exports.KeyringV1Adapter = void 0;
+const utils_1 = require("@metamask/utils");
 /**
  * Generic adapter that wraps a v2 {@link KeyringV2} instance and exposes it
  * through the v1 {@link BaseKeyring} interface expected by `KeyringController`.
@@ -81,4 +82,28 @@ class KeyringV1Adapter {
     }
 }
 exports.KeyringV1Adapter = KeyringV1Adapter;
+/**
+ * Check whether the given value is a {@link KeyringV1Adapter}, including
+ * subclasses such as `EthKeyringV1Adapter` or `SnapKeyringV1Adapter`.
+ *
+ * This is a structural check on the adapter's public surface, not an
+ * `instanceof` check: a consumer may hold a different copy of this package
+ * than the one that constructed the adapter (a split dependency tree), in
+ * which case `instanceof` is always `false`. `unwrap` is the distinguishing
+ * API — no v1 or v2 keyring exposes it — and it is the method consumers call
+ * to retrieve the inner v2 instance.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `KeyringV1Adapter`.
+ */
+function isKeyringV1Adapter(value) {
+    if (!(0, utils_1.isObject)(value)) {
+        return false;
+    }
+    // Property access rather than `hasProperty`: `unwrap` is a prototype
+    // method, not an own property, so own-property checks miss it.
+    const { type, unwrap } = value;
+    return typeof type === 'string' && typeof unwrap === 'function';
+}
+exports.isKeyringV1Adapter = isKeyringV1Adapter;
 //# sourceMappingURL=keyring-v1-adapter.cjs.map

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

@@ -1 +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;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW;QACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAChD,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,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW,CAAC,KAAW;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IACvC,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  protected 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"]}
+{"version":3,"file":"keyring-v1-adapter.cjs","sourceRoot":"","sources":["../../src/v2/keyring-v1-adapter.ts"],"names":[],"mappings":";;;AAGA,2CAA2C;AAG3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,gBAAgB;IAU3B,YAAY,KAAmB;QAC7B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAED;;;;;;;OAOG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW;QACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAChD,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,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,WAAW,CAAC,KAAW;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;CACF;AA9DD,4CA8DC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,kBAAkB,CAChC,KAAc;IAEd,IAAI,CAAC,IAAA,gBAAQ,EAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,qEAAqE;IACrE,+DAA+D;IAC/D,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,KAA6C,CAAC;IAEvE,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,MAAM,KAAK,UAAU,CAAC;AAClE,CAAC;AAZD,gDAYC","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 { isObject } from '@metamask/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  protected 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\n/**\n * Check whether the given value is a {@link KeyringV1Adapter}, including\n * subclasses such as `EthKeyringV1Adapter` or `SnapKeyringV1Adapter`.\n *\n * This is a structural check on the adapter's public surface, not an\n * `instanceof` check: a consumer may hold a different copy of this package\n * than the one that constructed the adapter (a split dependency tree), in\n * which case `instanceof` is always `false`. `unwrap` is the distinguishing\n * API — no v1 or v2 keyring exposes it — and it is the method consumers call\n * to retrieve the inner v2 instance.\n *\n * @param value - The value to check.\n * @returns Whether the value is a `KeyringV1Adapter`.\n */\nexport function isKeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2>(\n  value: unknown,\n): value is KeyringV1Adapter<InnerKeyring> {\n  if (!isObject(value)) {\n    return false;\n  }\n\n  // Property access rather than `hasProperty`: `unwrap` is a prototype\n  // method, not an own property, so own-property checks miss it.\n  const { type, unwrap } = value as { type?: unknown; unwrap?: unknown };\n\n  return typeof type === 'string' && typeof unwrap === 'function';\n}\n"]}

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

@@ -73,4 +73,19 @@ export declare class KeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2
      */
     deserialize(state: Json): Promise<void>;
 }
+/**
+ * Check whether the given value is a {@link KeyringV1Adapter}, including
+ * subclasses such as `EthKeyringV1Adapter` or `SnapKeyringV1Adapter`.
+ *
+ * This is a structural check on the adapter's public surface, not an
+ * `instanceof` check: a consumer may hold a different copy of this package
+ * than the one that constructed the adapter (a split dependency tree), in
+ * which case `instanceof` is always `false`. `unwrap` is the distinguishing
+ * API — no v1 or v2 keyring exposes it — and it is the method consumers call
+ * to retrieve the inner v2 instance.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `KeyringV1Adapter`.
+ */
+export declare function isKeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2>(value: unknown): value is KeyringV1Adapter<InnerKeyring>;
 //# sourceMappingURL=keyring-v1-adapter.d.cts.map

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

@@ -1 +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;IAEtB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;gBAE3B,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"}
+{"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;AAE3D,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;IAEtB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;gBAE3B,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;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,SAAS,SAAS,GAAG,SAAS,EAC3E,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,gBAAgB,CAAC,YAAY,CAAC,CAUzC"}

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

@@ -73,4 +73,19 @@ export declare class KeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2
      */
     deserialize(state: Json): Promise<void>;
 }
+/**
+ * Check whether the given value is a {@link KeyringV1Adapter}, including
+ * subclasses such as `EthKeyringV1Adapter` or `SnapKeyringV1Adapter`.
+ *
+ * This is a structural check on the adapter's public surface, not an
+ * `instanceof` check: a consumer may hold a different copy of this package
+ * than the one that constructed the adapter (a split dependency tree), in
+ * which case `instanceof` is always `false`. `unwrap` is the distinguishing
+ * API — no v1 or v2 keyring exposes it — and it is the method consumers call
+ * to retrieve the inner v2 instance.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a `KeyringV1Adapter`.
+ */
+export declare function isKeyringV1Adapter<InnerKeyring extends KeyringV2 = KeyringV2>(value: unknown): value is KeyringV1Adapter<InnerKeyring>;
 //# sourceMappingURL=keyring-v1-adapter.d.mts.map

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

@@ -1 +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;IAEtB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;gBAE3B,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"}
+{"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;AAE3D,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;IAEtB,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;gBAE3B,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;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,SAAS,SAAS,GAAG,SAAS,EAC3E,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,gBAAgB,CAAC,YAAY,CAAC,CAUzC"}