@lydianpay/lydianconnect 0.0.0-managed → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lydian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @lydianpay/lydianconnect
+
+One API for every wallet. LydianConnect abstracts the messy differences between
+wallet connection methods into a single, uniform interface.
+
+## Install
+
+```bash
+npm install @lydianpay/lydianconnect
+```
+
+## Usage
+
+```ts
+import { LydianConnect } from '@lydianpay/lydianconnect';
+
+const lc = new LydianConnect({
+  appName: 'My App',
+  walletConnectProjectId: 'your-wc-project-id',
+  icon: 'https://my.app/icon.png',   // optional
+  description: 'My App checkout',     // optional
+});
+
+const conn = await lc.connect({ walletId: 'metamask', chainId: 137 });
+const txHash = await conn.request({ method: 'eth_sendTransaction', params: [tx] });
+
+lc.on((event) => {
+  // 'connect' | 'disconnect' | 'chainChanged' | 'accountsChanged' | 'display_uri' | 'wallet_open_failed'
+});
+```
+
+## Config
+
+| Field | Required | Notes |
+|-------|----------|-------|
+| `appName` | yes | Display name shown in the wallet's connect prompt. |
+| `walletConnectProjectId` | yes | WalletConnect Cloud project id. |
+| `icon` | no | Icon shown in the connect prompt. |
+| `description` | no | Defaults to `appName`. |
+
+`connect({ walletId, chainId })` — `chainId` is the chain the user is paying on (a number like `137`, or a CAIP-2 id like `'eip155:137'`).
+
+## Supported wallets
+
+**Native SDK:** MetaMask, Coinbase Wallet.
+
+**WalletConnect:** Rainbow, Trust Wallet, OKX Wallet, Crypto.com, Phantom, Zerion,
+Argent, Ledger, 1inch, SafePal, imToken, TokenPocket, Blockchain.com, Exodus,
+Ronin Wallet, Coin98, Bitget Wallet, Infinity Wallet, Atomic Wallet, AlphaWallet,
+MathWallet, BitPay — each with native deep-linking.

package/dist/index.cjs

@@ -8,20 +8,26 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var SignClient__default = /*#__PURE__*/_interopDefault(SignClient);
 
 // src/core/manager.ts
-var LydianConnect = class {
-  constructor(config) {
+var ConnectManager = class {
+  constructor(connectors) {
     this.byWallet = /* @__PURE__ */ new Map();
     this.connections = /* @__PURE__ */ new Map();
     this.handlers = /* @__PURE__ */ new Set();
     this.unsubs = [];
     this.started = false;
-    this.fallback = config.fallback;
-    this.all = [...config.connectors ?? [], config.fallback];
-    for (const connector of config.connectors ?? []) {
+    const fallbacks = connectors.filter((c) => c.walletIds.length === 0);
+    if (fallbacks.length !== 1) {
+      throw new Error(
+        `LydianConnect requires exactly one fallback connector (empty walletIds); found ${fallbacks.length}`
+      );
+    }
+    this.fallback = fallbacks[0];
+    this.all = connectors;
+    for (const connector of connectors) {
       for (const id of connector.walletIds) this.byWallet.set(id, connector);
     }
   }
-  /** Wire connector event forwarding, once. Safe to call repeatedly. */
+  /** Wire connector event forwarding, once. */
   async init() {
     if (this.started) return;
     this.started = true;
@@ -29,18 +35,17 @@ var LydianConnect = class {
       this.unsubs.push(connector.on((event) => this.handle(event)));
     }
   }
-  /** SDK connector if one claims this walletId, else the WC fallback. The host app is oblivious. */
+  /** SDK connector if one claims this walletId, else the fallback. The host app is oblivious. */
   resolve(walletId) {
     return this.byWallet.get(walletId) ?? this.fallback;
   }
-  async connect(input) {
+  async connect(req) {
     if (!this.started) await this.init();
-    const connection = await this.resolve(input.walletId).connect(input);
-    this.connections.set(input.walletId, connection);
-    this.emit({ type: "connect", walletId: input.walletId, connection });
+    const connection = await this.resolve(req.walletId).connect(req);
+    this.connections.set(req.walletId, connection);
+    this.emit({ type: "connect", walletId: req.walletId, connection });
     return connection;
   }
-  /** Resume any live sessions across all connectors (e.g. after a page reload). */
   async restore() {
     if (!this.started) await this.init();
     const restored = [];
@@ -66,7 +71,6 @@ var LydianConnect = class {
     await Promise.allSettled([...this.connections.values()].map((c) => c.disconnect()));
     this.connections.clear();
   }
-  /** Disconnect everything and clear all connector-held state. */
   async reset() {
     await this.disconnect();
     await Promise.allSettled(this.all.map((c) => c.reset()));
@@ -84,6 +88,28 @@ var LydianConnect = class {
   }
 };
 
+// src/core/namespace.ts
+var DEFAULT_EVM_METHODS = [
+  "eth_sendTransaction",
+  "personal_sign",
+  "eth_signTypedData_v4",
+  "wallet_switchEthereumChain"
+];
+var DEFAULT_EVM_EVENTS = ["chainChanged", "accountsChanged"];
+function buildNamespace(chainId) {
+  const caip = typeof chainId === "number" ? `eip155:${chainId}` : chainId;
+  const [name, reference] = caip.split(":");
+  if (name !== "eip155" || !reference || !/^\d+$/.test(reference) || Number(reference) <= 0) {
+    throw new Error(
+      `Unsupported chain "${caip}". lydianconnect is EVM-only for now \u2014 pass a positive number or an "eip155:<id>" string.`
+    );
+  }
+  return {
+    name,
+    value: { chains: [caip], methods: DEFAULT_EVM_METHODS, events: DEFAULT_EVM_EVENTS }
+  };
+}
+
 // src/core/connector.ts
 var BaseConnector = class {
   constructor() {
@@ -104,6 +130,227 @@ var BaseConnector = class {
   }
 };
 
+// src/core/app.ts
+function deriveUrl() {
+  return typeof window !== "undefined" ? window.location.origin : "";
+}
+
+// src/connectors/metamask/connector.ts
+var WALLET_ID = "metamask";
+var MetaMaskConnector = class extends BaseConnector {
+  constructor(app) {
+    super();
+    this.app = app;
+    this.type = "sdk";
+    this.walletIds = [WALLET_ID];
+    this.sdk = null;
+    this.provider = null;
+    this.listenersBound = false;
+  }
+  isAvailable() {
+    return true;
+  }
+  async getProvider() {
+    if (this.provider) return this.provider;
+    const { MetaMaskSDK } = await import('@metamask/sdk');
+    const dappMetadata = {
+      name: this.app.appName,
+      url: deriveUrl(),
+      ...this.app.icon ? { iconUrl: this.app.icon } : {}
+    };
+    const sdk = new MetaMaskSDK({ dappMetadata });
+    await sdk.init();
+    const provider = sdk.getProvider();
+    if (!provider) throw new Error("MetaMask provider unavailable");
+    this.sdk = sdk;
+    this.provider = provider;
+    this.bindEvents(provider);
+    return provider;
+  }
+  bindEvents(provider) {
+    if (this.listenersBound) return;
+    this.listenersBound = true;
+    provider.on("chainChanged", (hex) => {
+      this.emit({ type: "chainChanged", walletId: WALLET_ID, chainId: toCaip(String(hex)) });
+    });
+    provider.on("accountsChanged", (accounts) => {
+      const account = Array.isArray(accounts) ? accounts[0] : void 0;
+      if (account) this.emit({ type: "accountsChanged", walletId: WALLET_ID, account });
+      else this.emit({ type: "disconnect", walletId: WALLET_ID });
+    });
+    provider.on("disconnect", () => this.emit({ type: "disconnect", walletId: WALLET_ID }));
+  }
+  async connect(req) {
+    const provider = await this.getProvider();
+    const accounts = await provider.request({ method: "eth_requestAccounts" });
+    const account = accounts?.[0];
+    if (!account) throw new Error("MetaMask returned no account");
+    await this.ensureChain(provider, req);
+    const chainId = toCaip(await provider.request({ method: "eth_chainId" }));
+    return this.toConnection(provider, account, chainId);
+  }
+  async restore() {
+    const provider = await this.getProvider().catch(() => null);
+    if (!provider) return [];
+    const accounts = await provider.request({ method: "eth_accounts" }).catch(() => []);
+    const account = accounts?.[0];
+    if (!account) return [];
+    const chainId = toCaip(
+      await provider.request({ method: "eth_chainId" }).catch(() => "0x1")
+    );
+    return [this.toConnection(provider, account, chainId)];
+  }
+  async reset() {
+    await this.sdk?.terminate();
+    this.provider = null;
+    this.listenersBound = false;
+  }
+  /** Best-effort switch to the requested chain; leaves the wallet as-is if it's unknown to it. */
+  async ensureChain(provider, req) {
+    const wanted = req.namespace.value.chains?.[0];
+    const wantedNum = wanted ? Number(wanted.split(":")[1]) : NaN;
+    if (!Number.isFinite(wantedNum) || wantedNum <= 0) return;
+    const current = parseInt(
+      await provider.request({ method: "eth_chainId" }).catch(() => "0x0") ?? "0x0",
+      16
+    );
+    if (current === wantedNum) return;
+    await provider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: `0x${wantedNum.toString(16)}` }]
+    }).catch(() => {
+    });
+  }
+  toConnection(provider, account, chainId) {
+    return {
+      walletId: WALLET_ID,
+      account,
+      chainId,
+      request: async (args) => await provider.request({ method: args.method, params: args.params }),
+      disconnect: async () => {
+        await this.sdk?.terminate();
+        this.provider = null;
+        this.listenersBound = false;
+        this.emit({ type: "disconnect", walletId: WALLET_ID });
+      }
+    };
+  }
+};
+function toCaip(hexChainId) {
+  if (!hexChainId) return "eip155:1";
+  const num = hexChainId.startsWith("0x") ? parseInt(hexChainId, 16) : Number(hexChainId);
+  return `eip155:${Number.isFinite(num) ? num : 1}`;
+}
+
+// src/connectors/coinbase/connector.ts
+function rpc(provider, method, params) {
+  return provider.request({ method, params });
+}
+var WALLET_ID2 = "coinbase";
+var CoinbaseConnector = class extends BaseConnector {
+  constructor(app) {
+    super();
+    this.app = app;
+    this.type = "sdk";
+    this.walletIds = [WALLET_ID2];
+    this.provider = null;
+    this.listenersBound = false;
+  }
+  isAvailable() {
+    return true;
+  }
+  async getProvider(appChainIds) {
+    if (this.provider) return this.provider;
+    const { CoinbaseWalletSDK } = await import('@coinbase/wallet-sdk');
+    const sdk = new CoinbaseWalletSDK({
+      appName: this.app.appName,
+      appLogoUrl: this.app.icon,
+      appChainIds
+      // one-time SDK-init hint; ensureChain enforces the actual chain per connect
+    });
+    const provider = sdk.makeWeb3Provider();
+    this.provider = provider;
+    this.bindEvents(provider);
+    return provider;
+  }
+  bindEvents(provider) {
+    if (this.listenersBound) return;
+    this.listenersBound = true;
+    provider.on("chainChanged", (hex) => {
+      this.emit({ type: "chainChanged", walletId: WALLET_ID2, chainId: toCaip2(String(hex)) });
+    });
+    provider.on("accountsChanged", (accounts) => {
+      const account = Array.isArray(accounts) ? accounts[0] : void 0;
+      if (account) this.emit({ type: "accountsChanged", walletId: WALLET_ID2, account });
+      else this.emit({ type: "disconnect", walletId: WALLET_ID2 });
+    });
+    provider.on("disconnect", () => this.emit({ type: "disconnect", walletId: WALLET_ID2 }));
+  }
+  async connect(req) {
+    const provider = await this.getProvider(evmChainIds(req));
+    const accounts = await rpc(provider, "eth_requestAccounts");
+    const account = accounts?.[0];
+    if (!account) throw new Error("Coinbase Wallet returned no account");
+    await this.ensureChain(provider, req);
+    const chainId = toCaip2(await rpc(provider, "eth_chainId"));
+    return this.toConnection(provider, account, chainId);
+  }
+  async restore() {
+    const provider = await this.getProvider().catch(() => null);
+    if (!provider) return [];
+    const accounts = await rpc(provider, "eth_accounts").catch(() => []);
+    const account = accounts?.[0];
+    if (!account) return [];
+    const chainId = toCaip2(await rpc(provider, "eth_chainId").catch(() => "0x1"));
+    return [this.toConnection(provider, account, chainId)];
+  }
+  async reset() {
+    await this.provider?.disconnect().catch(() => {
+    });
+    this.provider = null;
+    this.listenersBound = false;
+  }
+  async ensureChain(provider, req) {
+    const wanted = req.namespace.value.chains?.[0];
+    const wantedNum = wanted ? Number(wanted.split(":")[1]) : NaN;
+    if (!Number.isFinite(wantedNum) || wantedNum <= 0) return;
+    const current = parseInt(
+      await rpc(provider, "eth_chainId").catch(() => "0x0") ?? "0x0",
+      16
+    );
+    if (current === wantedNum) return;
+    await rpc(provider, "wallet_switchEthereumChain", [{ chainId: `0x${wantedNum.toString(16)}` }]).catch(
+      () => {
+      }
+    );
+  }
+  toConnection(provider, account, chainId) {
+    return {
+      walletId: WALLET_ID2,
+      account,
+      chainId,
+      request: (args) => rpc(provider, args.method, args.params),
+      disconnect: async () => {
+        await provider.disconnect().catch(() => {
+        });
+        this.provider = null;
+        this.listenersBound = false;
+        this.emit({ type: "disconnect", walletId: WALLET_ID2 });
+      }
+    };
+  }
+};
+function toCaip2(hexChainId) {
+  if (!hexChainId) return "eip155:1";
+  const num = hexChainId.startsWith("0x") ? parseInt(hexChainId, 16) : Number(hexChainId);
+  return `eip155:${Number.isFinite(num) ? num : 1}`;
+}
+function evmChainIds(req) {
+  const wanted = req.namespace.value.chains?.[0];
+  const n = wanted ? Number(wanted.split(":")[1]) : NaN;
+  return Number.isFinite(n) && n > 0 ? [n] : void 0;
+}
+
 // src/connectors/walletconnect/wallet-links.generated.ts
 var GENERATED_WALLET_LINKS = {
   metamask: { "scheme": "metamask://wc", "universal": "https://metamask.app.link/wc", "store": { "ios": "https://apps.apple.com/us/app/metamask/id1438144202", "android": "https://play.google.com/store/apps/details?id=io.metamask" } },
@@ -196,9 +443,10 @@ function detectAppOpen(timeoutMs) {
 // src/connectors/walletconnect/connector.ts
 var STORAGE_KEY = "lydianconnect.wc.topics";
 var WalletConnectConnector = class extends BaseConnector {
-  constructor(config) {
+  constructor(app, options) {
     super();
-    this.config = config;
+    this.app = app;
+    this.options = options;
     this.type = "walletconnect";
     this.walletIds = [];
     // claims any wallet not served by an SDK connector
@@ -206,7 +454,7 @@ var WalletConnectConnector = class extends BaseConnector {
     this.topics = /* @__PURE__ */ new Map();
     this.warm = null;
     this.warming = null;
-    this.links = { ...DEFAULT_WALLET_LINKS, ...config.walletLinks ?? {} };
+    this.links = { ...DEFAULT_WALLET_LINKS, ...options.walletLinks ?? {} };
   }
   isAvailable() {
     return true;
@@ -214,9 +462,14 @@ var WalletConnectConnector = class extends BaseConnector {
   async getClient() {
     if (this.client) return this.client;
     const client = await SignClient__default.default.init({
-      projectId: this.config.projectId,
-      metadata: this.config.metadata,
-      relayUrl: this.config.relayUrl
+      projectId: this.options.projectId,
+      metadata: {
+        name: this.app.appName,
+        description: this.app.description ?? this.app.appName,
+        url: deriveUrl(),
+        icons: this.app.icon ? [this.app.icon] : []
+      },
+      relayUrl: this.options.relayUrl
     });
     client.on("session_delete", ({ topic }) => {
       const walletId = this.walletForTopic(topic);
@@ -266,7 +519,7 @@ var WalletConnectConnector = class extends BaseConnector {
       const link = this.links[req.walletId];
       if (link) {
         openWallet(link, warm.uri);
-        void detectAppOpen(this.config.openTimeoutMs ?? 2e3).then((opened) => {
+        void detectAppOpen(this.options.openTimeoutMs ?? 2e3).then((opened) => {
           if (!opened) this.emit({ type: "wallet_open_failed", walletId: req.walletId, uri: warm.uri });
         });
       }
@@ -405,216 +658,53 @@ function withSignal(promise, signal, onAbort) {
   });
 }
 
-// src/connectors/metamask/connector.ts
-var WALLET_ID = "metamask";
-var MetaMaskConnector = class extends BaseConnector {
-  constructor(config) {
-    super();
-    this.config = config;
-    this.type = "sdk";
-    this.walletIds = [WALLET_ID];
-    this.sdk = null;
-    this.provider = null;
-    this.listenersBound = false;
-  }
-  isAvailable() {
-    return true;
-  }
-  async getProvider() {
-    if (this.provider) return this.provider;
-    const { MetaMaskSDK } = await import('@metamask/sdk');
-    const sdk = new MetaMaskSDK({
-      dappMetadata: this.config.dappMetadata,
-      ...this.config.sdkOptions
-    });
-    await sdk.init();
-    const provider = sdk.getProvider();
-    if (!provider) throw new Error("MetaMask provider unavailable");
-    this.sdk = sdk;
-    this.provider = provider;
-    this.bindEvents(provider);
-    return provider;
-  }
-  bindEvents(provider) {
-    if (this.listenersBound) return;
-    this.listenersBound = true;
-    provider.on("chainChanged", (hex) => {
-      this.emit({ type: "chainChanged", walletId: WALLET_ID, chainId: toCaip(String(hex)) });
-    });
-    provider.on("accountsChanged", (accounts) => {
-      const account = Array.isArray(accounts) ? accounts[0] : void 0;
-      if (account) this.emit({ type: "accountsChanged", walletId: WALLET_ID, account });
-      else this.emit({ type: "disconnect", walletId: WALLET_ID });
-    });
-    provider.on("disconnect", () => this.emit({ type: "disconnect", walletId: WALLET_ID }));
-  }
-  async connect(req) {
-    const provider = await this.getProvider();
-    const accounts = await provider.request({ method: "eth_requestAccounts" });
-    const account = accounts?.[0];
-    if (!account) throw new Error("MetaMask returned no account");
-    await this.ensureChain(provider, req);
-    const chainId = toCaip(await provider.request({ method: "eth_chainId" }));
-    return this.toConnection(provider, account, chainId);
-  }
-  async restore() {
-    const provider = await this.getProvider().catch(() => null);
-    if (!provider) return [];
-    const accounts = await provider.request({ method: "eth_accounts" }).catch(() => []);
-    const account = accounts?.[0];
-    if (!account) return [];
-    const chainId = toCaip(
-      await provider.request({ method: "eth_chainId" }).catch(() => "0x1")
-    );
-    return [this.toConnection(provider, account, chainId)];
-  }
-  async reset() {
-    await this.sdk?.terminate();
-    this.provider = null;
-    this.listenersBound = false;
-  }
-  /** Best-effort switch to the requested chain; leaves the wallet as-is if it's unknown to it. */
-  async ensureChain(provider, req) {
-    const wanted = req.namespace.value.chains?.[0];
-    const wantedNum = wanted ? Number(wanted.split(":")[1]) : NaN;
-    if (!Number.isFinite(wantedNum) || wantedNum <= 0) return;
-    const current = parseInt(
-      await provider.request({ method: "eth_chainId" }).catch(() => "0x0") ?? "0x0",
-      16
-    );
-    if (current === wantedNum) return;
-    await provider.request({
-      method: "wallet_switchEthereumChain",
-      params: [{ chainId: `0x${wantedNum.toString(16)}` }]
-    }).catch(() => {
-    });
-  }
-  toConnection(provider, account, chainId) {
-    return {
-      walletId: WALLET_ID,
-      account,
-      chainId,
-      request: async (args) => await provider.request({ method: args.method, params: args.params }),
-      disconnect: async () => {
-        await this.sdk?.terminate();
-        this.provider = null;
-        this.listenersBound = false;
-        this.emit({ type: "disconnect", walletId: WALLET_ID });
-      }
-    };
-  }
-};
-function toCaip(hexChainId) {
-  if (!hexChainId) return "eip155:1";
-  const num = hexChainId.startsWith("0x") ? parseInt(hexChainId, 16) : Number(hexChainId);
-  return `eip155:${Number.isFinite(num) ? num : 1}`;
+// src/core/lydian-connect.ts
+function createConnectors(config) {
+  const app = {
+    appName: config.appName,
+    icon: config.icon,
+    description: config.description
+  };
+  return [
+    new MetaMaskConnector(app),
+    new CoinbaseConnector(app),
+    new WalletConnectConnector(app, { projectId: config.walletConnectProjectId })
+  ];
 }
-
-// src/connectors/coinbase/connector.ts
-function rpc(provider, method, params) {
-  return provider.request({ method, params });
-}
-var WALLET_ID2 = "coinbase";
-var CoinbaseConnector = class extends BaseConnector {
+var LydianConnect = class {
   constructor(config) {
-    super();
-    this.config = config;
-    this.type = "sdk";
-    this.walletIds = [WALLET_ID2];
-    this.provider = null;
-    this.listenersBound = false;
+    this.manager = new ConnectManager(createConnectors(config));
   }
-  isAvailable() {
-    return true;
+  init() {
+    return this.manager.init();
   }
-  async getProvider() {
-    if (this.provider) return this.provider;
-    const { CoinbaseWalletSDK } = await import('@coinbase/wallet-sdk');
-    const sdk = new CoinbaseWalletSDK({
-      appName: this.config.appName,
-      appLogoUrl: this.config.appLogoUrl,
-      appChainIds: this.config.appChainIds
+  async connect(input) {
+    if (input.chainId === void 0 || input.chainId === null) {
+      throw new Error('connect() requires a chainId (a number like 137 or an "eip155:<id>" string)');
+    }
+    return this.manager.connect({
+      walletId: input.walletId,
+      namespace: buildNamespace(input.chainId),
+      signal: input.signal
     });
-    const provider = sdk.makeWeb3Provider();
-    this.provider = provider;
-    this.bindEvents(provider);
-    return provider;
   }
-  bindEvents(provider) {
-    if (this.listenersBound) return;
-    this.listenersBound = true;
-    provider.on("chainChanged", (hex) => {
-      this.emit({ type: "chainChanged", walletId: WALLET_ID2, chainId: toCaip2(String(hex)) });
-    });
-    provider.on("accountsChanged", (accounts) => {
-      const account = Array.isArray(accounts) ? accounts[0] : void 0;
-      if (account) this.emit({ type: "accountsChanged", walletId: WALLET_ID2, account });
-      else this.emit({ type: "disconnect", walletId: WALLET_ID2 });
-    });
-    provider.on("disconnect", () => this.emit({ type: "disconnect", walletId: WALLET_ID2 }));
+  restore() {
+    return this.manager.restore();
   }
-  async connect(req) {
-    const provider = await this.getProvider();
-    const accounts = await rpc(provider, "eth_requestAccounts");
-    const account = accounts?.[0];
-    if (!account) throw new Error("Coinbase Wallet returned no account");
-    await this.ensureChain(provider, req);
-    const chainId = toCaip2(await rpc(provider, "eth_chainId"));
-    return this.toConnection(provider, account, chainId);
+  disconnect(walletId) {
+    return this.manager.disconnect(walletId);
   }
-  async restore() {
-    const provider = await this.getProvider().catch(() => null);
-    if (!provider) return [];
-    const accounts = await rpc(provider, "eth_accounts").catch(() => []);
-    const account = accounts?.[0];
-    if (!account) return [];
-    const chainId = toCaip2(await rpc(provider, "eth_chainId").catch(() => "0x1"));
-    return [this.toConnection(provider, account, chainId)];
+  reset() {
+    return this.manager.reset();
   }
-  async reset() {
-    await this.provider?.disconnect().catch(() => {
-    });
-    this.provider = null;
-    this.listenersBound = false;
-  }
-  async ensureChain(provider, req) {
-    const wanted = req.namespace.value.chains?.[0];
-    const wantedNum = wanted ? Number(wanted.split(":")[1]) : NaN;
-    if (!Number.isFinite(wantedNum) || wantedNum <= 0) return;
-    const current = parseInt(await rpc(provider, "eth_chainId").catch(() => "0x0"), 16);
-    if (current === wantedNum) return;
-    await rpc(provider, "wallet_switchEthereumChain", [{ chainId: `0x${wantedNum.toString(16)}` }]).catch(
-      () => {
-      }
-    );
+  get(walletId) {
+    return this.manager.get(walletId);
   }
-  toConnection(provider, account, chainId) {
-    return {
-      walletId: WALLET_ID2,
-      account,
-      chainId,
-      request: (args) => rpc(provider, args.method, args.params),
-      disconnect: async () => {
-        await provider.disconnect().catch(() => {
-        });
-        this.provider = null;
-        this.listenersBound = false;
-        this.emit({ type: "disconnect", walletId: WALLET_ID2 });
-      }
-    };
+  on(handler) {
+    return this.manager.on(handler);
   }
 };
-function toCaip2(hexChainId) {
-  if (!hexChainId) return "eip155:1";
-  const num = hexChainId.startsWith("0x") ? parseInt(hexChainId, 16) : Number(hexChainId);
-  return `eip155:${Number.isFinite(num) ? num : 1}`;
-}
 
-exports.BaseConnector = BaseConnector;
-exports.CoinbaseConnector = CoinbaseConnector;
-exports.DEFAULT_WALLET_LINKS = DEFAULT_WALLET_LINKS;
 exports.LydianConnect = LydianConnect;
-exports.MetaMaskConnector = MetaMaskConnector;
-exports.WalletConnectConnector = WalletConnectConnector;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map