@multiplatform.one/web3 8.2.2 → 8.4.0

package/src/connectkit/adapters/TronAdapter.ts

@@ -0,0 +1,168 @@
+import type { TronNetwork } from "../../clients/tron";
+import type { WalletEntry } from "./discover";
+import type { SignInMessageOptions, WalletAdapter, WalletAddress } from "./types";
+
+interface TronWebLike {
+  ready?: boolean;
+  defaultAddress?: { base58?: string | false };
+  fullNode?: { host?: string };
+  trx: { signMessageV2(message: string): Promise<string> };
+}
+
+interface TronRequester {
+  request(args: { method: string; params?: unknown }): Promise<unknown>;
+}
+
+interface Tip1193Provider extends TronRequester {
+  tronWeb?: TronWebLike | false;
+  on?(event: "accountsChanged", listener: (accounts: string[]) => void): void;
+  removeListener?(event: "accountsChanged", listener: (accounts: string[]) => void): void;
+}
+
+interface TronLinkLike extends TronRequester {
+  ready?: boolean;
+  tronWeb?: TronWebLike | false;
+}
+
+interface TronWindow {
+  tron?: Tip1193Provider;
+  tronLink?: TronLinkLike;
+  tronWeb?: TronWebLike | false;
+  addEventListener?: Window["addEventListener"];
+  removeEventListener?: Window["removeEventListener"];
+}
+
+const page = (): TronWindow | undefined =>
+  typeof window === "undefined" ? undefined : (window as unknown as TronWindow);
+
+const tronWebOf = (w: TronWindow): TronWebLike | undefined =>
+  w.tron?.tronWeb || w.tronLink?.tronWeb || w.tronWeb || undefined;
+
+const accountOf = (w: TronWindow): string | null => tronWebOf(w)?.defaultAddress?.base58 || null;
+
+/** The network TronLink's full node is on, from its host. Mainnet for an unknown node. */
+export function tronNetworkOf(host: string | undefined): TronNetwork {
+  if (host?.includes("nile")) return "nile";
+  if (host?.includes("shasta")) return "shasta";
+  return "mainnet";
+}
+
+/** TronLink is on this page: the TIP-1193 `window.tron`, or the older `window.tronLink`. */
+export function hasTronWallet(): boolean {
+  const w = page();
+  return Boolean(w?.tron || w?.tronLink);
+}
+
+/**
+ * TronLink over its injected provider: `tron_requestAccounts` (or TIP-1193's
+ * `eth_requestAccounts`) to connect, `tronWeb.defaultAddress.base58` for the
+ * account, `tronWeb.trx.signMessageV2` to sign. No tronweb package.
+ */
+export class TronAdapter implements WalletAdapter {
+  readonly chain = "tron";
+  address: WalletAddress | null = null;
+  isConnected = false;
+
+  get network(): TronNetwork {
+    const w = page();
+    return tronNetworkOf(w ? tronWebOf(w)?.fullNode?.host : undefined);
+  }
+
+  get networkId(): string {
+    return `tron:${this.network}`;
+  }
+
+  async connect(): Promise<void> {
+    const w = page();
+    if (!w?.tron && !w?.tronLink) {
+      throw new Error("No Tron wallet found. Install TronLink.");
+    }
+    if (w.tron) {
+      await w.tron.request({ method: "eth_requestAccounts" });
+    } else if (w.tronLink) {
+      const answer = (await w.tronLink.request({ method: "tron_requestAccounts" })) as
+        | { code?: number; message?: string }
+        | ""
+        | undefined;
+      if (!answer) throw new Error("TronLink is locked. Unlock it and try again.");
+      if (answer.code !== undefined && answer.code !== 200) {
+        throw new Error(answer.message || "TronLink refused the connection");
+      }
+    }
+    const address = accountOf(w);
+    if (!address) throw new Error("TronLink returned no account");
+    this.address = address;
+    this.isConnected = true;
+  }
+
+  /**
+   * Takes the account TronLink already shares with this page, without a
+   * prompt. False when it shares none; throws while TronLink has not
+   * injected itself yet.
+   */
+  async restore(): Promise<boolean> {
+    const w = page();
+    if (!w?.tron && !w?.tronLink && !w?.tronWeb) throw new Error("No Tron wallet found yet.");
+    const address = accountOf(w);
+    this.address = address;
+    this.isConnected = address !== null;
+    return address !== null;
+  }
+
+  /** TronLink's account switches and disconnects; the account is read back from tronWeb on each. */
+  subscribe(listener: () => void): () => void {
+    const w = page();
+    if (!w) return () => {};
+    const update = () => {
+      const address = accountOf(w);
+      this.address = address;
+      this.isConnected = address !== null;
+      listener();
+    };
+    const provider = w.tron;
+    if (provider?.on) {
+      const onAccounts = () => update();
+      provider.on("accountsChanged", onAccounts);
+      return () => provider.removeListener?.("accountsChanged", onAccounts);
+    }
+    if (typeof w.addEventListener !== "function") return () => {};
+    const onMessage = (event: MessageEvent) => {
+      const action = (event.data as { message?: { action?: string } } | null)?.message?.action;
+      if (
+        action === "accountsChanged" ||
+        action === "setAccount" ||
+        action === "disconnect" ||
+        action === "disconnectWeb"
+      ) {
+        update();
+      }
+    };
+    w.addEventListener("message", onMessage as EventListener);
+    return () => w.removeEventListener?.("message", onMessage as EventListener);
+  }
+
+  async disconnect(): Promise<void> {
+    this.address = null;
+    this.isConnected = false;
+  }
+
+  async buildMessage(_opts: SignInMessageOptions): Promise<string> {
+    throw new Error("Tron sign-in is not supported yet");
+  }
+
+  /** TronLink's `signMessageV2`: the 0x hex signature over the TIP-191 prefixed message. */
+  async signMessage(message: string): Promise<string> {
+    const w = page();
+    const tronWeb = w ? tronWebOf(w) : undefined;
+    if (!this.address || !tronWeb) throw new Error("connect a Tron wallet first");
+    return tronWeb.trx.signMessageV2(message);
+  }
+}
+
+/** TronLink when it is on the page, as the one Tron wallet entry. */
+export function discoverTronWallets(): WalletEntry[] {
+  if (!hasTronWallet()) return [];
+  return [
+    { id: "wallet:tron:tronlink", name: "TronLink", ecosystem: "tron", adapter: new TronAdapter() },
+  ];
+}

package/src/connectkit/adapters/discover.ts

@@ -4,7 +4,7 @@ import { SolanaAdapter, isStandardSolanaWallet, standardSolanaProvider } from ".
 import { SuiAdapter, discoverSuiWallets } from "./SuiAdapter";
 import { BitcoinAdapter } from "./BitcoinAdapter";
 
-export type WalletEcosystem = "solana" | "sui" | "bitcoin";
+export type WalletEcosystem = "solana" | "sui" | "bitcoin" | "tron";
 
 export interface WalletEntry {
   /** Stable id, e.g. "wallet:solana:phantom" — matches a walletConfigs key. */

package/src/connectkit/connectors/createWalletMessage.ts

@@ -3,9 +3,9 @@ import { ecosystemBySyntheticChainId } from "./syntheticChains";
 
 /** Derive the signer family from the (possibly synthetic) chainId of the active connector. */
 export function familyFromChainId(chainId?: number): SignerFamily {
-  if (chainId != null && ecosystemBySyntheticChainId[chainId]) {
-    return ecosystemBySyntheticChainId[chainId];
-  }
+  const ecosystem = chainId == null ? undefined : ecosystemBySyntheticChainId[chainId];
+  if (ecosystem === "tron") throw new Error("Tron sign-in is not supported yet");
+  if (ecosystem) return ecosystem;
   return "evm";
 }
 

package/src/connectkit/connectors/ensureWalletConnectors.ts

@@ -2,6 +2,7 @@ import type { Config, Connector, CreateConnectorFn } from "wagmi";
 
 import { getConnectorEcosystem } from "@multiplatform.one/connectkit";
 import { discoverWallets } from "../adapters/discover";
+import { discoverTronWallets } from "../adapters/TronAdapter";
 import { ecosystemBySyntheticChainId } from "./syntheticChains";
 import { walletAdapterConnector } from "./walletAdapterConnector";
 
@@ -38,7 +39,7 @@ export function ensureWalletConnectors(config: Config): number {
   ]);
   const existing = new Set(config.connectors.map((c) => c.id));
   let added = 0;
-  for (const entry of discoverWallets()) {
+  for (const entry of [...discoverWallets(), ...discoverTronWallets()]) {
     if (existing.has(entry.id) || !listed.has(entry.ecosystem)) continue;
     const fn = walletAdapterConnector({
       id: entry.id,

package/src/connectkit/connectors/syntheticChains.ts

@@ -8,7 +8,7 @@
 import type { Chain } from "viem";
 import type { Ecosystem } from "@multiplatform.one/connectkit";
 
-// 0x534f4c="SOL", 0x535549="SUI", 0x425443="BTC" — reserved, collision-free vs
+// 0x534f4c="SOL", 0x535549="SUI", 0x425443="BTC", 0x545258="TRX" — reserved, collision-free vs
 // real EVM chainIds.
 /** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in a later major when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const SOLANA_CHAIN_ID = 0x534f4c; // 5_459_788
@@ -16,17 +16,21 @@ export const SOLANA_CHAIN_ID = 0x534f4c; // 5_459_788
 export const SUI_CHAIN_ID = 0x535549; // 5_461_321
 /** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in a later major when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const BITCOIN_CHAIN_ID = 0x425443; // 4_347_459
+/** @deprecated The wagmi shim for Solana, Sui, Bitcoin and Tron wallets, which goes in a later major when the connect modal reads the connection store (MPO-385). Use the `tron()` family from `./tron` and `useConnection()`. */
+export const TRON_CHAIN_ID = 0x545258; // 5_526_104
 
 export const syntheticChainIdByEcosystem: Record<Exclude<Ecosystem, "evm">, number> = {
   solana: SOLANA_CHAIN_ID,
   sui: SUI_CHAIN_ID,
   bitcoin: BITCOIN_CHAIN_ID,
+  tron: TRON_CHAIN_ID,
 };
 
 export const ecosystemBySyntheticChainId: Record<number, Ecosystem> = {
   [SOLANA_CHAIN_ID]: "solana",
   [SUI_CHAIN_ID]: "sui",
   [BITCOIN_CHAIN_ID]: "bitcoin",
+  [TRON_CHAIN_ID]: "tron",
 };
 
 /** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in a later major when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
@@ -56,6 +60,8 @@ export const solanaChain = makeChain(SOLANA_CHAIN_ID, "Solana", "SOL", 9);
 export const suiChain = makeChain(SUI_CHAIN_ID, "Sui", "SUI", 9);
 /** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in a later major when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
 export const bitcoinChain = makeChain(BITCOIN_CHAIN_ID, "Bitcoin", "BTC", 8);
+/** @deprecated The wagmi shim for Solana, Sui, Bitcoin and Tron wallets, which goes in a later major when the connect modal reads the connection store (MPO-385). Use the `tron()` family from `./tron` and `useConnection()`. */
+export const tronChain = makeChain(TRON_CHAIN_ID, "Tron", "TRX", 6);
 
 /** @deprecated The wagmi shim for Solana, Sui and Bitcoin wallets, which goes in a later major when the connect modal reads the connection store (MPO-385). Use the `sol()`, `sui()` and `btc()` families and `useConnection()`. */
-export const syntheticChains: Chain[] = [solanaChain, suiChain, bitcoinChain];
+export const syntheticChains: Chain[] = [solanaChain, suiChain, bitcoinChain, tronChain];

package/src/connectkit/defaultConfig.ts

@@ -7,6 +7,7 @@ import { setAppMeta } from "@multiplatform.one/connectkit";
 import defaultConnectors from "./defaultConnectors";
 import type { RestoredSessionTimeout } from "./connectors/restoredSession";
 import { discoverWallets, type WalletEcosystem } from "./adapters/discover";
+import { discoverTronWallets } from "./adapters/TronAdapter";
 import { getWalletConnectors } from "./connectors/getWalletConnectors";
 import { ecosystemBySyntheticChainId, syntheticChains } from "./connectors/syntheticChains";
 
@@ -32,7 +33,7 @@ type DefaultConfigProps = {
   metaMaskRestoredSessionTimeout?: RestoredSessionTimeout;
   // wallet: append shim-connectors for any detected non-EVM wallet (Solana/Sui/
   // Bitcoin) alongside the EVM connectors. No-op when none are installed. A list
-  // limits it to those ecosystems.
+  // limits it to those ecosystems; Tron is listed only when a list names it.
   enableWallet?: boolean | readonly WalletEcosystem[];
 } & Partial<CreateConfigParameters>;
 
@@ -90,7 +91,9 @@ const defaultConfig = ({
     ? [
         ...(baseConnectors ?? []),
         ...getWalletConnectors(
-          discoverWallets().filter((entry) => ecosystems.includes(entry.ecosystem)),
+          [...discoverWallets(), ...discoverTronWallets()].filter((entry) =>
+            ecosystems.includes(entry.ecosystem),
+          ),
         ),
       ]
     : baseConnectors;

package/src/connectkit/siwe/SIWEContext.tsx

@@ -61,6 +61,8 @@ export type SIWEContextValue = Required<Omit<SIWEConfig, "onSign" | "subscribeNo
     nonce: ReturnType<typeof useQuery<string | null>>;
     session: ReturnType<typeof useQuery<SIWESession | null>>;
     status: StatusState;
+    /** What ended the last sign-in, while status is ERROR or REJECTED. */
+    error: Error | null;
     signIn: () => Promise<SIWESession | false>;
     resetStatus: () => void;
   };

package/src/connectkit/siwe/SIWEProvider.tsx

@@ -26,6 +26,20 @@ const b64 = (s: string) => window.btoa(unescape(encodeURIComponent(s)));
  * connection store holds: `<SignInProvider {...kc.signInConfig(onSign)}>`,
  * or Web3Provider's `signIn` prop.
  */
+// A transport wraps the wallet's own refusal (viem's HttpRequestError around a
+// 4001), so the code can sit anywhere down the cause chain.
+function isUserRejection(error: unknown): boolean {
+  for (
+    let cause = error as { code?: unknown; cause?: unknown } | undefined, depth = 0;
+    cause && depth < 8;
+    cause = cause.cause as typeof cause, depth++
+  ) {
+    if (cause.code === -32000 || cause.code === 4001 || cause.code === "ACTION_REJECTED")
+      return true;
+  }
+  return false;
+}
+
 export const SIWEProvider = ({
   children,
   enabled = true,
@@ -39,7 +53,11 @@ export const SIWEProvider = ({
   ...siweConfig
 }: Props) => {
   const [status, setStatus] = useState<StatusState>(StatusState.READY);
-  const resetStatus = () => setStatus(StatusState.READY);
+  const [error, setError] = useState<Error | null>(null);
+  const resetStatus = () => {
+    setStatus(StatusState.READY);
+    setError(null);
+  };
 
   // Only allow for mounting SIWEProvider once, so we avoid weird global state
   // collisions.
@@ -111,15 +129,8 @@ export const SIWEProvider = ({
 
   const onError = (error: any) => {
     console.error("signIn error", error, error.message);
-    switch (error.code) {
-      case -32000: // user rejected, as some wallets report it
-      case 4001: // MetaMask: user rejected
-      case "ACTION_REJECTED": // MetaMask: user rejected
-        setStatus(StatusState.REJECTED);
-        break;
-      default:
-        setStatus(StatusState.ERROR);
-    }
+    setError(error instanceof Error ? error : new Error(String(error)));
+    setStatus(isUserRejection(error) ? StatusState.REJECTED : StatusState.ERROR);
   };
 
   const signIn = async () => {
@@ -135,6 +146,7 @@ export const SIWEProvider = ({
       if (!chainId) throw new Error("No chainId found");
 
       setStatus(StatusState.LOADING);
+      setError(null);
 
       // Fetch this sign-in's own nonce. A server that consumes its nonce on
       // verify refuses the one cached at mount the second time, so a cached
@@ -249,6 +261,7 @@ export const SIWEProvider = ({
         signIn,
         signOut: signOutAndRefetch,
         status,
+        error,
         resetStatus,
       }}
     >

package/src/connectkit/wallets/walletConfigs.tsx

@@ -89,6 +89,14 @@ export const walletConfigs: {
     icon: <BrandIcon bg="#000000" fg="#FFFFFF" glyph="OK" />,
     iconShape: "squircle",
   },
+  "wallet:tron:tronlink": {
+    icon: <BrandIcon bg="#EB0029" fg="#FFFFFF" glyph="T" />,
+    iconShape: "squircle",
+    downloadUrls: {
+      website: "https://www.tronlink.org",
+      chrome: "https://chromewebstore.google.com/detail/tronlink/ibnejdfjmmkpcnlpebklmnkoeoihofec",
+    },
+  },
   aaveAccountProvider: {
     name: "Aave Account",
     shortName: "Aave",

package/src/families/host.ts

@@ -1,9 +1,11 @@
 import type { Config } from "wagmi";
 import type { SolanaChain } from "../clients/solanaMessage";
+import type { ChainClient } from "../clients/types";
+import type { WalletAdapter } from "../connectkit/adapters/types";
 import type { WalletFamily } from "../core/family";
 
-/** The ecosystem a wagmi connector carries: `evm`, or a Solana, Sui or Bitcoin shim's. */
-export type HostedEcosystem = "evm" | "solana" | "sui" | "bitcoin";
+/** The ecosystem a wagmi connector carries: `evm`, or a Solana, Sui, Bitcoin or Tron shim's. */
+export type HostedEcosystem = "evm" | "solana" | "sui" | "bitcoin" | "tron";
 
 /**
  * How a Web3Provider hosts a built-in family on its wagmi config while the
@@ -19,6 +21,11 @@ export interface WagmiHosting {
   readonly solanaChain?: SolanaChain;
   /** The wagmi config the app gave `eth()`, which the provider then uses. */
   readonly config?: Config;
+  /**
+   * The family's client over its shim's adapter, for a family whose client
+   * the shared connector lookup does not build, such as Tron's web-only one.
+   */
+  readonly client?: (adapter: WalletAdapter) => ChainClient | null;
 }
 
 const hosting = new WeakMap<WalletFamily, WagmiHosting>();

package/src/families/tron.spec.ts

@@ -0,0 +1,118 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createConfig, http } from "wagmi";
+import { mainnet } from "wagmi/chains";
+import type { TronClient } from "../clients/tron";
+import { TronAdapter } from "../connectkit/adapters/TronAdapter";
+import { tronChain } from "../connectkit/connectors/syntheticChains";
+import { walletAdapterConnector } from "../connectkit/connectors/walletAdapterConnector";
+import { createFamilyRegistry } from "../core/family";
+import { hostFamiliesOnWagmi } from "../wagmi/host";
+import { wagmiHosting } from "./host";
+import { walletFamilies } from "./index";
+import { tron, tronDriver } from "./tron";
+
+const address = "TKHuVq1oKVruCGLvqVexFs6dawKv6fQgFs";
+const usdt = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t";
+const globals: string[] = [];
+const install = (name: string, value: unknown) => {
+  globals.push(name);
+  (window as unknown as Record<string, unknown>)[name] = value;
+};
+
+afterEach(() => {
+  for (const name of globals.splice(0)) Reflect.deleteProperty(window, name);
+  vi.unstubAllGlobals();
+});
+
+function injectTronLink(host = "https://nile.trongrid.io") {
+  const web = {
+    defaultAddress: { base58: false as string | false },
+    fullNode: { host },
+    trx: { signMessageV2: vi.fn(async () => "0xsig") },
+  };
+  install("tronLink", {
+    tronWeb: web,
+    request: vi.fn(async () => {
+      web.defaultAddress.base58 = address;
+      return { code: 200 };
+    }),
+  });
+  install("tronWeb", web);
+  return web;
+}
+
+function trongrid(word = "2a") {
+  const fetch = vi.fn(async (_url: string | URL | Request, _init?: RequestInit) =>
+    Response.json({ result: { result: true }, constant_result: [word] }),
+  );
+  vi.stubGlobal("fetch", fetch);
+  return fetch;
+}
+
+describe("the tron family", () => {
+  it("is its own family, beside the built-in ones and not among them", () => {
+    const family = tron();
+    expect(family).toMatchObject({ id: "tron", label: "Tron", aliases: ["trx"] });
+    expect(createFamilyRegistry([family]).require("trx")).toBe(family);
+    expect(wagmiHosting(family)).toMatchObject({ ecosystem: "tron", chainId: "tron" });
+    expect(walletFamilies().map((entry) => entry.id)).not.toContain("tron");
+  });
+
+  it("connects TronLink on the light driver and reads TRC-20 on TronLink's network", async () => {
+    injectTronLink();
+    const fetch = trongrid();
+    const driver = tronDriver();
+    expect(driver.connectors()).toEqual([{ id: "wallet:tron:tronlink", name: "TronLink" }]);
+    await expect(driver.connect("wallet:tron:tronlink")).resolves.toEqual({
+      address,
+      chainId: "tron",
+    });
+    const client = (await driver.client?.(driver.getState())) as TronClient;
+    expect(client).toMatchObject({ family: "tron", address, network: "nile" });
+    await expect(client.trc20Balance(usdt)).resolves.toBe(42n);
+    expect(fetch.mock.calls[0][0]).toBe("https://nile.trongrid.io/wallet/triggerconstantcontract");
+  });
+
+  it("hears TronLink when it injects itself after the page loaded", () => {
+    const driver = tronDriver();
+    expect(driver.connectors()).toEqual([]);
+    const changed = vi.fn();
+    const unwatch = driver.watchConnectors?.(changed);
+    injectTronLink();
+    window.dispatchEvent(new Event("tronLink#initialized"));
+    expect(changed).toHaveBeenCalledTimes(1);
+    expect(driver.connectors()).toHaveLength(1);
+    unwatch?.();
+    window.dispatchEvent(new Event("tronLink#initialized"));
+    expect(changed).toHaveBeenCalledTimes(1);
+  });
+
+  it("hosted on wagmi, connects through the modal's shim and hands back its Tron client", async () => {
+    injectTronLink("https://api.trongrid.io");
+    trongrid("0");
+    const adapter = new TronAdapter();
+    const config = createConfig({
+      chains: [mainnet, tronChain],
+      connectors: [
+        walletAdapterConnector({
+          id: "wallet:tron:tronlink",
+          name: "TronLink",
+          ecosystem: "tron",
+          adapter,
+        }),
+      ],
+      transports: { [mainnet.id]: http(), [tronChain.id]: http() },
+    });
+    const [hosted] = hostFamiliesOnWagmi([tron()], config);
+    const driver = hosted.driver?.();
+    expect(driver?.connectors().map((connector) => connector.id)).toEqual(["wallet:tron:tronlink"]);
+    await expect(driver?.connect("wallet:tron:tronlink")).resolves.toEqual({
+      address,
+      chainId: "tron",
+    });
+    const client = (await driver?.client?.(driver.getState())) as TronClient;
+    expect(client).toMatchObject({ family: "tron", address, network: "mainnet" });
+    await expect(client.trc20Balance(usdt)).resolves.toBe(0n);
+  });
+});

package/src/families/tron.ts

@@ -0,0 +1,63 @@
+import { tronClient, type TronClientOptions } from "../clients/tron";
+import { discoverTronWallets, TronAdapter } from "../connectkit/adapters/TronAdapter";
+import type { WalletMessageSpec } from "../core/message";
+import { defineWalletFamily, type WalletFamily } from "../core/family";
+import { lightDriver } from "../core/lightDriver";
+import type { ConnectionDriver } from "../core/types";
+import { withHosting } from "./host";
+
+export const tronMessage: WalletMessageSpec = {
+  header: "wants you to sign in with your Tron account:",
+  statement: "Sign in With Tron.",
+  chainId: "tron",
+};
+
+export type TronFamilyOptions = Omit<TronClientOptions, "network">;
+
+const networkOf = (adapter: unknown) =>
+  adapter instanceof TronAdapter ? { network: adapter.network } : {};
+
+/** TronLink on the light driver. Hears TronLink when it injects itself after the page loaded. */
+export function tronDriver(options: TronFamilyOptions = {}): ConnectionDriver {
+  return lightDriver({
+    wallets: () => discoverTronWallets().map(({ id, name, adapter }) => ({ id, name, adapter })),
+    watchWallets(listener) {
+      if (typeof window === "undefined" || typeof window.addEventListener !== "function") {
+        return () => {};
+      }
+      const announced = (event: Event) => {
+        const action = (event as MessageEvent<{ message?: { action?: string } } | null>).data
+          ?.message?.action;
+        if (event.type === "tronLink#initialized" || action === "tabReply") listener();
+      };
+      window.addEventListener("tronLink#initialized", announced);
+      window.addEventListener("message", announced);
+      return () => {
+        window.removeEventListener("tronLink#initialized", announced);
+        window.removeEventListener("message", announced);
+      };
+    },
+    chainId: "tron",
+    client: (wallet) => tronClient(wallet.adapter, { ...options, ...networkOf(wallet.adapter) }),
+  });
+}
+
+/**
+ * The Tron family: TronLink, through the connect modal under Web3Provider.
+ * Its client reads TRC-20 balances through TronGrid on the network TronLink
+ * is on. Web only, from `@multiplatform.one/web3/tron`.
+ */
+export function tron(options: TronFamilyOptions = {}): WalletFamily {
+  const family = defineWalletFamily({
+    id: "tron",
+    label: "Tron",
+    aliases: ["trx"],
+    message: tronMessage,
+    driver: () => tronDriver(options),
+  });
+  return withHosting(family, {
+    ecosystem: "tron",
+    chainId: "tron",
+    client: (adapter) => tronClient(adapter, { ...options, ...networkOf(adapter) }),
+  });
+}