@multiplatform.one/web3 7.26.0 → 7.28.0

package/src/wagmi/driver.spec.ts

@@ -0,0 +1,407 @@
+import { connect, type Config } from "@wagmi/core";
+import { getAddress, verifyMessage, type Hex } from "viem";
+import { describe, expect, it, vi } from "vitest";
+import {
+  createWallets,
+  describeConnectionDriver,
+  type DriverHarness,
+} from "../../tests/core/driverContract";
+import { deferred } from "../../tests/core/testDriver";
+import { accountFor, keys, scriptedConnector, wagmiConfig } from "../../tests/core/wagmiWallets";
+import { clientForConnector } from "../clients/connector";
+import { connectorAdapter } from "../clients/adapter";
+import { walletAdapterConnector } from "../connectkit/connectors/walletAdapterConnector";
+import { SOLANA_CHAIN_ID } from "../connectkit/connectors/syntheticChains";
+import { wagmiDriver } from "./driver";
+
+const signers = Object.values(keys).map(accountFor);
+const byAddress = Object.fromEntries(signers.map((signer) => [signer.address, signer]));
+const [one, two, three, four] = signers as [
+  (typeof signers)[number],
+  (typeof signers)[number],
+  (typeof signers)[number],
+  (typeof signers)[number],
+];
+
+function setup(options: { displayUri?: string } = {}) {
+  const wallets = createWallets({
+    "wallet.one": one.address,
+    "wallet.two": two.address,
+    "wallet.three": three.address,
+  });
+  const build = () => {
+    const config = wagmiConfig([
+      scriptedConnector(wallets, "wallet.one", byAddress, { emitOnDisconnect: true, ...options }),
+      scriptedConnector(wallets, "wallet.two", byAddress),
+      scriptedConnector(wallets, "wallet.three", byAddress),
+    ]);
+    return { config, driver: wagmiDriver(config) };
+  };
+  const { config, driver } = build();
+  const connector = (id: string) => {
+    const found = config.connectors.find((entry) => entry.id === id);
+    if (!found) throw new Error(`no connector ${id}`);
+    return found;
+  };
+  const harness: DriverHarness = {
+    driver,
+    wallets,
+    first: "wallet.one",
+    second: "wallet.two",
+    third: "wallet.three",
+    otherAddress: four.address,
+    multiple: true,
+    normalize: (address) => getAddress(address),
+    switchAccount(id, address) {
+      wallets.get(id).address = address;
+      connector(id).onAccountsChanged([address]);
+    },
+    walletDisconnect(id) {
+      wallets.get(id).open = false;
+      connector(id).onDisconnect();
+    },
+    remount: () => build().driver,
+    verify: (address, message, signature) =>
+      verifyMessage({ address: getAddress(address), message, signature: signature as Hex }),
+  };
+  return { ...harness, config, connector };
+}
+
+describeConnectionDriver("wagmiDriver", setup);
+
+describe("wagmiDriver", () => {
+  it("hands a pairing URI to onDisplayUri while connecting, and stops after", async () => {
+    const { driver, config, connector } = setup({ displayUri: "metamask://wc?uri=pair" });
+    const onDisplayUri = vi.fn();
+    await driver.connect("wallet.one", { onDisplayUri });
+    expect(onDisplayUri).toHaveBeenCalledWith("metamask://wc?uri=pair");
+    connector("wallet.one").emitter.emit("message", { type: "display_uri", data: "late" });
+    expect(onDisplayUri).toHaveBeenCalledTimes(1);
+    expect(config.state.status).toBe("connected");
+  });
+
+  it("leaves the non-EVM shim connectors of the legacy config to their families", () => {
+    const wallets = createWallets({ "wallet.one": one.address });
+    const adapter = {
+      chain: "solana",
+      address: null,
+      networkId: null,
+      isConnected: false,
+      connect: async () => {},
+      disconnect: async () => {},
+      buildMessage: async () => "",
+      signMessage: async () => "",
+    };
+    const config = wagmiConfig([
+      scriptedConnector(wallets, "wallet.one", byAddress),
+      walletAdapterConnector({
+        id: "wallet:solana:phantom",
+        name: "Phantom",
+        ecosystem: "solana",
+        adapter,
+      }) as ReturnType<typeof scriptedConnector>,
+    ]);
+    expect(config.connectors.map((entry) => entry.id)).toContain("wallet:solana:phantom");
+    expect(
+      wagmiDriver(config)
+        .connectors()
+        .map((entry) => entry.id),
+    ).toEqual(["wallet.one"]);
+    const everything = wagmiDriver(config, { filter: () => true });
+    expect(everything.connectors().map((entry) => entry.id)).toEqual([
+      "wallet.one",
+      "wallet:solana:phantom",
+    ]);
+  });
+
+  it("connecting the connector that is already current prompts nothing", async () => {
+    const { driver, wallets } = setup();
+    const first = await driver.connect("wallet.one");
+    expect(await driver.connect("wallet.one")).toEqual(first);
+    expect(wallets.get("wallet.one").prompts).toBe(1);
+  });
+
+  it("connecting a connector that is open but not current switches to it without a prompt", async () => {
+    const { driver, wallets } = setup();
+    await driver.connect("wallet.one");
+    await driver.connect("wallet.two");
+    expect(driver.getState().connectorId).toBe("wallet.two");
+    const account = await driver.connect("wallet.one");
+    expect(account.address).toBe(getAddress(one.address));
+    expect(wallets.get("wallet.one").prompts).toBe(1);
+    expect(driver.getState().connectorId).toBe("wallet.one");
+  });
+
+  it("a restore that finds the wallet untrusted leaves another open connection alone", async () => {
+    const { driver, wallets, config } = setup();
+    await driver.connect("wallet.one");
+    expect(await driver.reconnect("wallet.two")).toBeNull();
+    expect(wallets.get("wallet.one").open).toBe(true);
+    expect(config.state.connections.size).toBe(1);
+    expect(driver.getState()).toMatchObject({ status: "connected", connectorId: "wallet.one" });
+  });
+
+  it("a restore of a connector wagmi already holds returns it without asking the wallet", async () => {
+    const { driver, wallets } = setup();
+    await driver.connect("wallet.one");
+    await driver.connect("wallet.two");
+    const account = await driver.reconnect("wallet.one");
+    expect(account?.address).toBe(getAddress(one.address));
+    expect(wallets.get("wallet.one")).toMatchObject({ prompts: 1, restores: 0 });
+    expect(driver.getState().connectorId).toBe("wallet.one");
+  });
+
+  it("follows a chain switch from the wallet", async () => {
+    const { driver, connector } = setup();
+    await driver.connect("wallet.one");
+    connector("wallet.one").onChainChanged("0x2105");
+    expect(driver.getState().account?.chainId).toBe(8453);
+  });
+
+  it("keeps one state object and one connector list while nothing changes", async () => {
+    const { driver } = setup();
+    await driver.connect("wallet.one");
+    expect(driver.getState()).toBe(driver.getState());
+    expect(driver.connectors()).toBe(driver.connectors());
+  });
+
+  it("tells watchConnectors when wagmi's list changes, as an EIP-6963 wallet announcing late does", () => {
+    const { driver, config } = setup();
+    const late = createWallets({ "wallet.four": four.address });
+    const listener = vi.fn();
+    const unwatch = driver.watchConnectors?.(listener);
+    const before = driver.connectors();
+    const internal = (config as Config)._internal.connectors;
+    internal.setState((list) => [
+      ...list,
+      internal.setup(scriptedConnector(late, "wallet.four", byAddress)),
+    ]);
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(driver.connectors()).not.toBe(before);
+    expect(driver.connectors()).toHaveLength(4);
+    unwatch?.();
+    internal.setState((list) => list.slice(0, 3));
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it("a connection that lands while another connector closes survives the close", async () => {
+    const { driver, wallets, config, connector } = setup();
+    await driver.connect("wallet.one");
+    const slow = deferred<void>();
+    vi.spyOn(connector("wallet.one"), "disconnect").mockImplementationOnce(async () => {
+      await slow.promise;
+      wallets.get("wallet.one").open = false;
+    });
+    const closing = driver.disconnect("wallet.one");
+    await driver.connect("wallet.two");
+    slow.resolve();
+    await closing;
+    expect([...config.state.connections.values()].map((c) => c.connector.id)).toEqual([
+      "wallet.two",
+    ]);
+    expect(driver.getState()).toMatchObject({ status: "connected", connectorId: "wallet.two" });
+    await driver.disconnect("wallet.two");
+    expect(wallets.get("wallet.two").open).toBe(false);
+  });
+
+  it("a restore the wallet answers with no account rejects and leaves nothing stuck", async () => {
+    const { driver, wallets, config, connector } = setup();
+    wallets.get("wallet.one").authorized = true;
+    vi.spyOn(connector("wallet.one"), "connect").mockResolvedValueOnce({
+      accounts: [],
+      chainId: 1,
+    } as never);
+    await expect(driver.reconnect("wallet.one")).rejects.toThrow(/no account/);
+    expect(config.state.connections.size).toBe(0);
+    expect(driver.getState()).toMatchObject({ status: "disconnected", account: null });
+    expect((await driver.connect("wallet.one")).address).toBe(getAddress(one.address));
+  });
+
+  it("a connector wagmi left current with no account connects again and closes", async () => {
+    const { driver, wallets, config, connector } = setup();
+    const stuck = connector("wallet.one");
+    config.setState((x) => ({
+      ...x,
+      connections: new Map(x.connections).set(stuck.uid, {
+        accounts: [] as never,
+        chainId: 1,
+        connector: stuck,
+      }),
+      current: stuck.uid,
+      status: "connected",
+    }));
+    expect(driver.getState().account).toBeNull();
+    expect((await driver.connect("wallet.one")).address).toBe(getAddress(one.address));
+    expect(wallets.get("wallet.one").prompts).toBe(1);
+    config.setState((x) => ({
+      ...x,
+      connections: new Map(x.connections).set(connector("wallet.two").uid, {
+        accounts: [] as never,
+        chainId: 1,
+        connector: connector("wallet.two"),
+      }),
+    }));
+    await driver.disconnect();
+    expect(config.state.connections.size).toBe(0);
+  });
+
+  it("a close the wallet fails still lets go, so the next connect prompts", async () => {
+    const { driver, wallets, config, connector } = setup();
+    await driver.connect("wallet.one");
+    vi.spyOn(connector("wallet.one"), "disconnect").mockRejectedValueOnce(
+      new Error("provider not found"),
+    );
+    await expect(driver.disconnect("wallet.one")).rejects.toThrow(/provider not found/);
+    expect(config.state.connections.size).toBe(0);
+    expect(driver.getState().account).toBeNull();
+    await driver.connect("wallet.one");
+    expect(wallets.get("wallet.one").prompts).toBe(2);
+  });
+
+  it("a close the wallet never answers lets go at once", async () => {
+    const { driver, wallets, config, connector } = setup();
+    await driver.connect("wallet.one");
+    vi.spyOn(connector("wallet.one"), "disconnect").mockReturnValueOnce(new Promise(() => {}));
+    void driver.disconnect("wallet.one");
+    expect(config.state.connections.size).toBe(0);
+    expect(driver.getState().account).toBeNull();
+    await driver.connect("wallet.one");
+    expect(wallets.get("wallet.one").prompts).toBe(2);
+  });
+
+  it("closing everything lets go of every connection at once, whatever one wallet does", async () => {
+    const { driver, wallets, config, connector } = setup();
+    await driver.connect("wallet.one");
+    await driver.connect("wallet.two");
+    vi.spyOn(connector("wallet.one"), "disconnect").mockReturnValueOnce(new Promise(() => {}));
+    void driver.disconnect();
+    expect(config.state.connections.size).toBe(0);
+    await vi.waitFor(() => expect(wallets.get("wallet.two").open).toBe(false));
+    await driver.connect("wallet.two");
+    expect(wallets.get("wallet.two").prompts).toBe(2);
+  });
+
+  it("reports the most recent of its connections when a shim's is current", async () => {
+    const wallets = createWallets({ "wallet.one": one.address, "wallet.two": two.address });
+    const shim = createWallets({ "wallet:solana:phantom": three.address });
+    const config = wagmiConfig([
+      scriptedConnector(wallets, "wallet.one", byAddress),
+      scriptedConnector(wallets, "wallet.two", byAddress),
+      scriptedConnector(shim, "wallet:solana:phantom", byAddress),
+    ]);
+    const phantom = config.connectors[2] as unknown as Record<string, unknown>;
+    phantom.ecosystem = "solana";
+    phantom.adapter = {};
+    const driver = wagmiDriver(config);
+    await driver.connect("wallet.one");
+    await driver.connect("wallet.two");
+    const connected = await connect(config, { connector: config.connectors[2] });
+    expect(connected.accounts[0]).toBe(getAddress(three.address));
+    expect(driver.getState().connectorId).toBe("wallet.two");
+  });
+
+  it("rejects a restore while the connector has no provider yet, and asks nothing", async () => {
+    const { driver, connector } = setup();
+    const authorized = vi.spyOn(connector("wallet.one"), "isAuthorized");
+    vi.spyOn(connector("wallet.one"), "getProvider").mockResolvedValueOnce(undefined);
+    await expect(driver.reconnect("wallet.one")).rejects.toThrow(/no provider/);
+    expect(authorized).not.toHaveBeenCalled();
+  });
+
+  it("a client built after a chain switch is on the new chain", async () => {
+    const { driver, connector } = setup();
+    await driver.connect("wallet.one");
+    connector("wallet.one").onChainChanged("0x2105");
+    const client = await driver.client?.(driver.getState());
+    expect(client).toMatchObject({ chainId: 8453 });
+  });
+
+  it("builds the mpo EVM client over the connected wallet", async () => {
+    const { driver } = setup();
+    await driver.connect("wallet.one");
+    const client = await driver.client?.(driver.getState());
+    expect(client).toMatchObject({
+      family: "evm",
+      address: getAddress(one.address),
+      chainId: 1,
+      capabilities: expect.arrayContaining(["sendTransaction", "writeContract"]),
+    });
+  });
+});
+
+describe("wagmiDriver hosting a Solana shim for its family", () => {
+  const phantomAddress = "7EcDhSYGxXyscszYEp35KHN8vvw3svAuLKTzXwCFLtV";
+
+  function shim() {
+    const wallets = createWallets({ "wallet.one": one.address });
+    const adapter = {
+      chain: "solana",
+      address: null as string | null,
+      networkId: null,
+      isConnected: false,
+      connect: vi.fn(async () => {
+        adapter.address = phantomAddress;
+        adapter.isConnected = true;
+      }),
+      disconnect: vi.fn(async () => {
+        adapter.address = null;
+        adapter.isConnected = false;
+      }),
+      buildMessage: async () => "",
+      signMessage: vi.fn(async (message: string) => `signed:${message}`),
+    };
+    const config = wagmiConfig([
+      scriptedConnector(wallets, "wallet.one", byAddress),
+      walletAdapterConnector({
+        id: "wallet:solana:phantom",
+        name: "Phantom",
+        ecosystem: "solana",
+        adapter,
+      }) as ReturnType<typeof scriptedConnector>,
+    ]);
+    const driver = wagmiDriver(config, {
+      filter: (connector) => connectorAdapter(connector, "solana") !== null,
+      chainId: "solana:devnet",
+      client: (connector) => clientForConnector(connector, { solanaChain: "solana:devnet" }),
+    });
+    return { config, driver, adapter };
+  }
+
+  it("reports the family's chain id in place of the shim's synthetic one", async () => {
+    const { config, driver } = shim();
+    expect(driver.connectors().map((entry) => entry.id)).toEqual(["wallet:solana:phantom"]);
+    const account = await driver.connect("wallet:solana:phantom");
+    expect(account).toEqual({ address: phantomAddress, chainId: "solana:devnet" });
+    expect(config.state.connections.values().next().value?.chainId).toBe(SOLANA_CHAIN_ID);
+    expect(driver.getState()).toMatchObject({
+      status: "connected",
+      connectorId: "wallet:solana:phantom",
+      account: { address: phantomAddress, chainId: "solana:devnet" },
+    });
+  });
+
+  it("builds the client its options give, over the shim's adapter", async () => {
+    const { driver, adapter } = shim();
+    await driver.connect("wallet:solana:phantom");
+    const client = await driver.client?.(driver.getState());
+    expect(client).toMatchObject({
+      family: "solana",
+      address: phantomAddress,
+      chainId: "solana:devnet",
+    });
+    expect(await client?.signMessage("hello")).toBe("signed:hello");
+    expect(adapter.signMessage).toHaveBeenCalledWith("hello");
+  });
+
+  it("hands over a shim connection wagmi already holds with no prompt", async () => {
+    const { config, driver, adapter } = shim();
+    const phantom = config.connectors.find((entry) => entry.id === "wallet:solana:phantom")!;
+    await connect(config, { connector: phantom });
+    expect(adapter.connect).toHaveBeenCalledTimes(1);
+    expect(await driver.reconnect("wallet:solana:phantom")).toEqual({
+      address: phantomAddress,
+      chainId: "solana:devnet",
+    });
+    expect(adapter.connect).toHaveBeenCalledTimes(1);
+  });
+});