@miden-sdk/miden-wallet-adapter-miden 0.16.2 → 0.16.3

package/conformance.ts

@@ -1,219 +0,0 @@
-// `EventEmitter` comes via the base package rather than `eventemitter3` directly:
-// base re-exports it and is a declared dependency here, eventemitter3 is not.
-import type { EventEmitter } from "@miden-sdk/miden-wallet-adapter-base";
-
-import type { MidenWallet, MidenWalletEvents } from "./adapter";
-
-/**
- * A conformance suite for `MidenWallet` implementations.
- *
- * ## Why this exists
- *
- * `createAccount` has been on the published `MidenWallet` interface since
- * adapter 0.13.2. No wallet provider implements it — not the browser
- * extension, not the mobile injection script, not the Tauri provider — and
- * there is no wire message for it. A dApp calling it gets
- * `TypeError: wallet.createAccount is not a function`.
- *
- * That shipped, and stayed shipped, because both sides of the contract were
- * green: this repo's tests inject a `vi.fn()` bag as `window.midenWallet`, and
- * the wallet's tests mock this package wholesale. Each side asserted against a
- * shape it invented.
- *
- * A suite written *here* cannot fix that. Whatever reference provider this
- * repo authors gets updated in the same commit that adds a method, so it can
- * never detect a missing one. The detection has to happen where the real
- * implementations live. So this module ships the *instrument*, and the wallet
- * runs it against its real providers.
- *
- * ## Two halves, deliberately separate
- *
- * {@link getSurfaceCases} asks only whether each method exists. It needs no
- * connection, no network and no state, so it is safe to run against providers
- * that are plain injected JavaScript — which is what the mobile and Tauri
- * providers are, and where the remaining gaps live.
- *
- * {@link getBehaviorCases} exercises round-trips and needs a live, connected
- * provider. Running it against an un-connected provider proves nothing.
- *
- * @packageDocumentation
- */
-
-/** Members `MidenWallet` inherits from EventEmitter rather than declaring. */
-type InheritedKeys = keyof EventEmitter<MidenWalletEvents>;
-
-/** Members `MidenWallet` declares itself. */
-type OwnKeys = Exclude<keyof MidenWallet, InheritedKeys>;
-
-/** The subset of {@link OwnKeys} that are callable — i.e. not `address`/`publicKey`. */
-type MethodKeys = {
-  [K in OwnKeys]-?: NonNullable<MidenWallet[K]> extends (
-    ...args: never[]
-  ) => unknown
-    ? K
-    : never;
-}[OwnKeys];
-
-/**
- * Every method a `MidenWallet` must implement.
- *
- * Type-locked in both directions below: a method added to the interface
- * without being added here fails to compile, and a name here that is not on
- * the interface fails to compile too. The list cannot silently drift from the
- * contract it describes.
- */
-export const MIDEN_WALLET_METHODS = [
-  "connect",
-  "disconnect",
-  "signBytes",
-  "requestSend",
-  "requestConsume",
-  "requestTransaction",
-  "requestAssets",
-  "requestGuardianInfo",
-  "requestPrivateNotes",
-  "requestConsumableNotes",
-  "importPrivateNote",
-  "waitForTransaction",
-  "createAccount",
-] as const satisfies readonly MethodKeys[];
-
-/** Compile error if the interface gains a method this list does not name. */
-type Unlisted = Exclude<MethodKeys, (typeof MIDEN_WALLET_METHODS)[number]>;
-const _exhaustive: [Unlisted] extends [never]
-  ? true
-  : ["MIDEN_WALLET_METHODS is missing", Unlisted] = true;
-void _exhaustive;
-
-/**
- * Identifies this module as the real implementation.
- *
- * The wallet mocks this package in a dozen test files. If a conformance run
- * ever lands inside a suite that mocks it — or someone later adds a
- * `moduleNameMapper` — the imported suite would become a no-op that still
- * reports green: the identical failure mode this whole fixture exists to
- * prevent, one layer up. Assert on this before running any case.
- */
-export const CONFORMANCE_BUILD = {
-  real: true,
-  methodCount: MIDEN_WALLET_METHODS.length,
-} as const;
-
-/** One assertion, named so a failure says what is wrong without a stack trace. */
-export interface ConformanceCase {
-  readonly name: string;
-  /** Throws on failure; returns normally on success. */
-  readonly run: () => void | Promise<void>;
-}
-
-/** Anything shaped enough to probe. Deliberately not `MidenWallet`: the point is to test providers that may not satisfy it. */
-export type ProviderLike = Record<string, unknown>;
-
-/**
- * Shape-only checks: does the provider expose every method?
- *
- * Safe against untyped, runtime-only providers — no connection or state
- * required. This is the half that catches a provider missing a method the
- * interface promises.
- */
-export function getSurfaceCases(provider: ProviderLike): ConformanceCase[] {
-  return MIDEN_WALLET_METHODS.map((method) => ({
-    name: `implements ${method}()`,
-    run: () => {
-      const value = provider[method];
-      if (typeof value !== "function") {
-        throw new Error(
-          `MidenWallet.${method} is ${value === undefined ? "missing" : `a ${typeof value}`}. ` +
-            `Every method on the published MidenWallet interface must exist on the provider; ` +
-            `a dApp calling this one gets "TypeError: wallet.${method} is not a function".`
-        );
-      }
-    },
-  }));
-}
-
-/**
- * Round-trip checks against a live, connected provider.
- *
- * Unlike {@link getSurfaceCases} these need real state, so a provider obtained
- * by evaluating an injection script — with no wallet behind it — will fail
- * them for reasons that say nothing about conformance. Run the surface half
- * against those.
- */
-export function getBehaviorCases(provider: ProviderLike): ConformanceCase[] {
-  const call = async <T>(method: string, ...args: unknown[]): Promise<T> => {
-    const fn = provider[method];
-    if (typeof fn !== "function") {
-      throw new Error(`MidenWallet.${method} is not a function`);
-    }
-    return (await (fn as (...a: unknown[]) => Promise<T>).apply(
-      provider,
-      args
-    )) as T;
-  };
-
-  return [
-    {
-      name: "requestAssets() resolves to { assets: [...] }",
-      run: async () => {
-        const result = await call<{ assets: unknown[] }>("requestAssets");
-        if (!result || !Array.isArray(result.assets)) {
-          throw new Error(
-            `requestAssets() must resolve to { assets: Asset[] }, got ${JSON.stringify(result)}`
-          );
-        }
-      },
-    },
-    {
-      name: "requestConsumableNotes() resolves to { consumableNotes: [...] }",
-      run: async () => {
-        const result = await call<{ consumableNotes: unknown[] }>(
-          "requestConsumableNotes"
-        );
-        if (!result || !Array.isArray(result.consumableNotes)) {
-          throw new Error(
-            `requestConsumableNotes() must resolve to { consumableNotes: InputNoteDetails[] }, got ${JSON.stringify(result)}`
-          );
-        }
-      },
-    },
-    {
-      name: "requestGuardianInfo() resolves to { guardianInfo }",
-      run: async () => {
-        const result = await call<{ guardianInfo: unknown }>(
-          "requestGuardianInfo"
-        );
-        if (!result || result.guardianInfo === undefined) {
-          throw new Error(
-            `requestGuardianInfo() must resolve to { guardianInfo: GuardianInfo }, got ${JSON.stringify(result)}`
-          );
-        }
-      },
-    },
-  ];
-}
-
-/**
- * Runs cases and collects every failure rather than stopping at the first.
- *
- * A provider missing four methods should report four failures, not one — the
- * point is to see the whole gap in a single run.
- */
-export async function runConformance(
-  cases: ConformanceCase[]
-): Promise<{ passed: string[]; failed: { name: string; error: string }[] }> {
-  const passed: string[] = [];
-  const failed: { name: string; error: string }[] = [];
-  for (const testCase of cases) {
-    try {
-      await testCase.run();
-      passed.push(testCase.name);
-    } catch (error) {
-      failed.push({
-        name: testCase.name,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
-  return { passed, failed };
-}

package/dist/__tests__/adapter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/adapter.test.js

@@ -1,464 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { WalletNotConnectedError, WalletTransactionError, WalletReadyState, WalletNotReadyError, WalletConnectionError, PrivateDataPermission, WalletAdapterNetwork, } from "@miden-sdk/miden-wallet-adapter-base";
-// Mock @miden-sdk/miden-sdk before importing adapter
-vi.mock("@miden-sdk/miden-sdk", () => ({
-    Note: {
-        deserialize: vi.fn((bytes) => ({ mockNote: true, bytes })),
-    },
-}));
-import { Note } from "@miden-sdk/miden-sdk";
-import { MidenWalletAdapter } from "../adapter";
-function createMockWallet(overrides = {}) {
-    return {
-        address: "0xmockaddress",
-        publicKey: new Uint8Array([1, 2, 3]),
-        connect: vi.fn(),
-        disconnect: vi.fn(),
-        requestSend: vi.fn().mockResolvedValue({ transactionId: "tx-send-1" }),
-        requestConsume: vi
-            .fn()
-            .mockResolvedValue({ transactionId: "tx-consume-1" }),
-        requestTransaction: vi
-            .fn()
-            .mockResolvedValue({ transactionId: "tx-custom-1" }),
-        requestAssets: vi
-            .fn()
-            .mockResolvedValue({ assets: [{ faucetId: "f1", amount: "100" }] }),
-        requestGuardianInfo: vi.fn().mockResolvedValue({
-            guardianInfo: {
-                isGuardianAccount: false,
-                guardianEndpoint: null,
-                guardianProvider: null,
-                guardianSyncStatus: null,
-            },
-        }),
-        requestPrivateNotes: vi
-            .fn()
-            .mockResolvedValue({ privateNotes: [{ noteId: "n1" }] }),
-        signBytes: vi
-            .fn()
-            .mockResolvedValue({ signature: new Uint8Array([9, 8, 7]) }),
-        importPrivateNote: vi.fn().mockResolvedValue({ noteId: "imported-note-1" }),
-        requestConsumableNotes: vi
-            .fn()
-            .mockResolvedValue({ consumableNotes: [{ noteId: "cn1" }] }),
-        createAccount: vi.fn().mockResolvedValue({ accountId: "account-123" }),
-        waitForTransaction: vi.fn(),
-        ...overrides,
-    };
-}
-// Helper to set up a connected adapter by injecting mock wallet via window
-async function createConnectedAdapter() {
-    const mockWallet = createMockWallet();
-    window.midenWallet = mockWallet;
-    const adapter = new MidenWalletAdapter();
-    // Force readyState to Installed so connect works
-    adapter.readyState = WalletReadyState.Installed;
-    await adapter.connect(PrivateDataPermission.UponRequest, WalletAdapterNetwork.Testnet);
-    return { adapter, mockWallet };
-}
-describe("MidenWalletAdapter", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        delete window.midenWallet;
-        delete window.miden;
-    });
-    describe("constructor", () => {
-        it("initializes with null address and not connecting", () => {
-            const adapter = new MidenWalletAdapter();
-            expect(adapter.address).toBeNull();
-            expect(adapter.publicKey).toBeNull();
-            expect(adapter.connecting).toBe(false);
-            expect(adapter.connected).toBe(false);
-        });
-        it("sets readyState to NotDetected when wallet is not present", () => {
-            const adapter = new MidenWalletAdapter();
-            expect(adapter.readyState).toBe(WalletReadyState.NotDetected);
-        });
-    });
-    describe("not connected errors", () => {
-        const methods = [
-            {
-                name: "requestSend",
-                call: (a) => a.requestSend({
-                    senderAddress: "s",
-                    recipientAddress: "r",
-                    faucetId: "f",
-                    noteType: "public",
-                    amount: 1,
-                }),
-            },
-            {
-                name: "requestConsume",
-                call: (a) => a.requestConsume({
-                    faucetId: "f",
-                    noteId: "n",
-                    noteType: "public",
-                    amount: 1,
-                }),
-            },
-            {
-                name: "requestTransaction",
-                call: (a) => a.requestTransaction({ type: "send", payload: {} }),
-            },
-            {
-                name: "requestAssets",
-                call: (a) => a.requestAssets(),
-            },
-            {
-                name: "requestGuardianInfo",
-                call: (a) => a.requestGuardianInfo(),
-            },
-            {
-                name: "requestPrivateNotes",
-                call: (a) => a.requestPrivateNotes("All"),
-            },
-            {
-                name: "signBytes",
-                call: (a) => a.signBytes(new Uint8Array([1]), "word"),
-            },
-            {
-                name: "importPrivateNote",
-                call: (a) => a.importPrivateNote(new Uint8Array([1])),
-            },
-            {
-                name: "requestConsumableNotes",
-                call: (a) => a.requestConsumableNotes(),
-            },
-            {
-                name: "waitForTransaction",
-                call: (a) => a.waitForTransaction("tx-1"),
-            },
-            {
-                name: "createAccount",
-                call: (a) => a.createAccount(),
-            },
-        ];
-        for (const { name, call } of methods) {
-            it(`${name} throws WalletNotConnectedError when not connected`, async () => {
-                const adapter = new MidenWalletAdapter();
-                const errorHandler = vi.fn();
-                adapter.on("error", errorHandler);
-                await expect(call(adapter)).rejects.toThrow(WalletNotConnectedError);
-                expect(errorHandler).toHaveBeenCalledWith(expect.any(WalletNotConnectedError));
-            });
-        }
-    });
-    describe("connected operations", () => {
-        it("requestSend delegates to wallet and returns transactionId", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const tx = {
-                senderAddress: "s",
-                recipientAddress: "r",
-                faucetId: "f",
-                noteType: "public",
-                amount: 100,
-            };
-            const result = await adapter.requestSend(tx);
-            expect(mockWallet.requestSend).toHaveBeenCalledWith(tx);
-            expect(result).toBe("tx-send-1");
-        });
-        it("requestConsume delegates to wallet and returns transactionId", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const tx = {
-                faucetId: "f",
-                noteId: "n",
-                noteType: "public",
-                amount: 50,
-            };
-            const result = await adapter.requestConsume(tx);
-            expect(mockWallet.requestConsume).toHaveBeenCalledWith(tx);
-            expect(result).toBe("tx-consume-1");
-        });
-        it("requestSend rejects (does not resolve undefined) when the wallet returns no transactionId (0xMiden/wallet#314)", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            // The wallet resolved "successfully" but without a transaction id — meaning
-            // the transaction was never submitted; the dApp must see a rejection.
-            mockWallet.requestSend.mockResolvedValue({});
-            const errorHandler = vi.fn();
-            adapter.on("error", errorHandler);
-            await expect(adapter.requestSend({
-                senderAddress: "s",
-                recipientAddress: "r",
-                faucetId: "f",
-                noteType: "public",
-                amount: 1,
-            })).rejects.toThrow(WalletTransactionError);
-            expect(errorHandler).toHaveBeenCalled();
-        });
-        it("requestConsume rejects when the wallet returns no transactionId (0xMiden/wallet#314)", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.requestConsume.mockResolvedValue({ transactionId: undefined });
-            await expect(adapter.requestConsume({
-                faucetId: "f",
-                noteId: "n",
-                noteType: "public",
-                amount: 1,
-            })).rejects.toThrow(WalletTransactionError);
-        });
-        it("requestTransaction (custom) rejects when the wallet returns no transactionId (0xMiden/wallet#314)", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.requestTransaction.mockResolvedValue({});
-            await expect(adapter.requestTransaction({
-                type: "custom",
-                payload: {},
-            })).rejects.toThrow(WalletTransactionError);
-            expect(mockWallet.requestTransaction).toHaveBeenCalled();
-        });
-        it("requestTransaction routes a Consume transaction to wallet.requestConsume (issue #88)", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const payload = {
-                faucetId: "f",
-                noteId: "n",
-                noteType: "public",
-                amount: 50,
-            };
-            const result = await adapter.requestTransaction({
-                type: "consume",
-                payload,
-            });
-            expect(mockWallet.requestConsume).toHaveBeenCalledWith(payload);
-            expect(mockWallet.requestTransaction).not.toHaveBeenCalled();
-            expect(result).toBe("tx-consume-1");
-        });
-        it("requestTransaction routes a Send transaction to wallet.requestSend", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const payload = {
-                senderAddress: "s",
-                recipientAddress: "r",
-                faucetId: "f",
-                noteType: "public",
-                amount: 100,
-            };
-            const result = await adapter.requestTransaction({
-                type: "send",
-                payload,
-            });
-            expect(mockWallet.requestSend).toHaveBeenCalledWith(payload);
-            expect(mockWallet.requestTransaction).not.toHaveBeenCalled();
-            expect(result).toBe("tx-send-1");
-        });
-        it("requestTransaction forwards a Custom transaction to wallet.requestTransaction", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const tx = {
-                type: "custom",
-                payload: {
-                    address: "addr",
-                    recipientAddress: "r",
-                    transactionRequest: "base64-request",
-                },
-            };
-            const result = await adapter.requestTransaction(tx);
-            expect(mockWallet.requestTransaction).toHaveBeenCalledWith(tx);
-            expect(result).toBe("tx-custom-1");
-        });
-        it("requestTransaction forwards a bare (typeless) payload to wallet.requestTransaction", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const tx = {
-                address: "addr",
-                transactionRequest: "base64-request",
-            };
-            const result = await adapter.requestTransaction(tx);
-            expect(mockWallet.requestTransaction).toHaveBeenCalledWith(tx);
-            expect(result).toBe("tx-custom-1");
-        });
-        it("requestAssets returns assets array", async () => {
-            const { adapter } = await createConnectedAdapter();
-            const assets = await adapter.requestAssets();
-            expect(assets).toEqual([{ faucetId: "f1", amount: "100" }]);
-        });
-        it("requestGuardianInfo unwraps the provider result", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.requestGuardianInfo.mockResolvedValue({
-                guardianInfo: {
-                    isGuardianAccount: true,
-                    guardianEndpoint: "https://g",
-                    guardianProvider: "gateway",
-                    guardianSyncStatus: "in-sync",
-                },
-            });
-            const guardianInfo = await adapter.requestGuardianInfo();
-            expect(guardianInfo).toEqual({
-                isGuardianAccount: true,
-                guardianEndpoint: "https://g",
-                guardianProvider: "gateway",
-                guardianSyncStatus: "in-sync",
-            });
-        });
-        it("requestGuardianInfo emits error and wraps failure", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.requestGuardianInfo.mockRejectedValue(new Error("network error"));
-            const errorHandler = vi.fn();
-            adapter.on("error", errorHandler);
-            await expect(adapter.requestGuardianInfo()).rejects.toThrow(WalletTransactionError);
-            expect(errorHandler).toHaveBeenCalledWith(expect.any(WalletTransactionError));
-        });
-        it("requestPrivateNotes returns notes array", async () => {
-            const { adapter } = await createConnectedAdapter();
-            const notes = await adapter.requestPrivateNotes("All");
-            expect(notes).toEqual([{ noteId: "n1" }]);
-        });
-        it("signBytes returns signature", async () => {
-            const { adapter } = await createConnectedAdapter();
-            const sig = await adapter.signBytes(new Uint8Array([1, 2]), "word");
-            expect(sig).toEqual(new Uint8Array([9, 8, 7]));
-        });
-        it("importPrivateNote returns noteId", async () => {
-            const { adapter } = await createConnectedAdapter();
-            const noteId = await adapter.importPrivateNote(new Uint8Array([1]));
-            expect(noteId).toBe("imported-note-1");
-        });
-        it("requestConsumableNotes returns consumable notes", async () => {
-            const { adapter } = await createConnectedAdapter();
-            const notes = await adapter.requestConsumableNotes();
-            expect(notes).toEqual([{ noteId: "cn1" }]);
-        });
-        it("createAccount returns accountId without params", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const result = await adapter.createAccount();
-            expect(mockWallet.createAccount).toHaveBeenCalledWith(undefined);
-            expect(result).toBe("account-123");
-        });
-        it("createAccount returns accountId with params", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const params = {
-                accountType: "RegularAccountUpdatableCode",
-                storageMode: "private",
-            };
-            const result = await adapter.createAccount(params);
-            expect(mockWallet.createAccount).toHaveBeenCalledWith(params);
-            expect(result).toBe("account-123");
-        });
-        it("createAccount passes customComponents to wallet", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const component = new Uint8Array([1, 2, 3]);
-            const params = { customComponents: [component] };
-            const result = await adapter.createAccount(params);
-            expect(mockWallet.createAccount).toHaveBeenCalledWith(params);
-            expect(result).toBe("account-123");
-        });
-    });
-    describe("waitForTransaction", () => {
-        it("success path: deserializes notes and returns TransactionOutput", async () => {
-            // base64 of [1,2,3] = "AQID"
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.waitForTransaction.mockResolvedValue({
-                txHash: "hash-123",
-                outputNotes: ["AQID", "BAUG"],
-            });
-            const result = await adapter.waitForTransaction("tx-1");
-            expect(result.txHash).toBe("hash-123");
-            expect(result.outputNotes).toHaveLength(2);
-            expect(Note.deserialize).toHaveBeenCalledTimes(2);
-        });
-        it("error path: throws WalletTransactionError on errorMessage", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.waitForTransaction.mockResolvedValue({
-                errorMessage: "tx failed",
-            });
-            const errorHandler = vi.fn();
-            adapter.on("error", errorHandler);
-            await expect(adapter.waitForTransaction("tx-1")).rejects.toThrow(WalletTransactionError);
-            expect(errorHandler).toHaveBeenCalled();
-        });
-    });
-    describe("connect", () => {
-        it("throws WalletNotReadyError if readyState is not Installed", async () => {
-            const adapter = new MidenWalletAdapter();
-            const errorHandler = vi.fn();
-            adapter.on("error", errorHandler);
-            await expect(adapter.connect(PrivateDataPermission.UponRequest, WalletAdapterNetwork.Testnet)).rejects.toThrow(WalletNotReadyError);
-        });
-        it("connects successfully and emits connect event", async () => {
-            const mockWallet = createMockWallet();
-            window.midenWallet = mockWallet;
-            const adapter = new MidenWalletAdapter();
-            adapter.readyState = WalletReadyState.Installed;
-            const connectHandler = vi.fn();
-            adapter.on("connect", connectHandler);
-            await adapter.connect(PrivateDataPermission.UponRequest, WalletAdapterNetwork.Testnet);
-            expect(adapter.address).toBe("0xmockaddress");
-            expect(adapter.publicKey).toEqual(new Uint8Array([1, 2, 3]));
-            expect(adapter.connected).toBe(true);
-            expect(adapter.connecting).toBe(false);
-            expect(connectHandler).toHaveBeenCalledWith("0xmockaddress");
-        });
-        it("throws WalletConnectionError if wallet has no address after connect", async () => {
-            const mockWallet = createMockWallet({ address: undefined });
-            window.midenWallet = mockWallet;
-            const adapter = new MidenWalletAdapter();
-            adapter.readyState = WalletReadyState.Installed;
-            await expect(adapter.connect(PrivateDataPermission.UponRequest, WalletAdapterNetwork.Testnet)).rejects.toThrow(WalletConnectionError);
-        });
-        it("re-drives the handshake and re-emits `connect` when called while already connected, repopulating the current account (0xMiden/wallet#470)", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            const connectHandler = vi.fn();
-            adapter.on("connect", connectHandler);
-            // The in-app browser preserves this adapter's JS context across a
-            // park/restore, so a re-opened dApp finds `connected === true`. The
-            // old early-return made a second connect() a silent no-op, so a
-            // re-mounted consumer that re-subscribed to events never got its
-            // account back ("Connect Wallet works only once"). A repeat connect()
-            // must re-drive the wallet handshake — which returns the current
-            // account — and re-emit `connect` so the consumer repopulates.
-            await adapter.connect(PrivateDataPermission.UponRequest, WalletAdapterNetwork.Testnet);
-            expect(mockWallet.connect).toHaveBeenCalledTimes(2);
-            expect(connectHandler).toHaveBeenCalledWith("0xmockaddress");
-            expect(adapter.connected).toBe(true);
-            expect(adapter.address).toBe("0xmockaddress");
-        });
-        it("ignores a concurrent connect() while one is still in flight", async () => {
-            let releaseFirstConnect = () => { };
-            const mockWallet = createMockWallet({
-                connect: vi.fn(() => new Promise((resolve) => {
-                    releaseFirstConnect = resolve;
-                })),
-            });
-            window.midenWallet = mockWallet;
-            const adapter = new MidenWalletAdapter();
-            adapter.readyState = WalletReadyState.Installed;
-            // First connect stays in flight (its wallet.connect() promise is pending).
-            const first = adapter.connect(PrivateDataPermission.UponRequest, WalletAdapterNetwork.Testnet);
-            // A second call while `connecting` is true must be a guarded no-op.
-            await adapter.connect(PrivateDataPermission.UponRequest, WalletAdapterNetwork.Testnet);
-            expect(mockWallet.connect).toHaveBeenCalledTimes(1);
-            releaseFirstConnect();
-            await first;
-            expect(adapter.connected).toBe(true);
-        });
-    });
-    describe("disconnect", () => {
-        it("clears address, publicKey, and emits disconnect", async () => {
-            const { adapter } = await createConnectedAdapter();
-            const disconnectHandler = vi.fn();
-            adapter.on("disconnect", disconnectHandler);
-            await adapter.disconnect();
-            expect(adapter.address).toBeNull();
-            expect(adapter.publicKey).toBeNull();
-            expect(adapter.connected).toBe(false);
-            expect(disconnectHandler).toHaveBeenCalled();
-        });
-        it("emits error if wallet.disconnect fails", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.disconnect.mockRejectedValue(new Error("disconnect failed"));
-            const errorHandler = vi.fn();
-            adapter.on("error", errorHandler);
-            await adapter.disconnect();
-            expect(errorHandler).toHaveBeenCalled();
-        });
-    });
-    describe("error wrapping", () => {
-        it("wraps wallet method failures in WalletTransactionError", async () => {
-            const { adapter, mockWallet } = await createConnectedAdapter();
-            mockWallet.requestSend.mockRejectedValue(new Error("network error"));
-            await expect(adapter.requestSend({
-                senderAddress: "s",
-                recipientAddress: "r",
-                faucetId: "f",
-                noteType: "public",
-                amount: 1,
-            })).rejects.toThrow(WalletTransactionError);
-        });
-    });
-});
-//# sourceMappingURL=adapter.test.js.map