@lydianpay/lydianconnect 0.0.0-managed

package/dist/index.cjs

@@ -0,0 +1,620 @@
+'use strict';
+
+var SignClient = require('@walletconnect/sign-client');
+var utils = require('@walletconnect/utils');
+
+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) {
+    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 ?? []) {
+      for (const id of connector.walletIds) this.byWallet.set(id, connector);
+    }
+  }
+  /** Wire connector event forwarding, once. Safe to call repeatedly. */
+  async init() {
+    if (this.started) return;
+    this.started = true;
+    for (const connector of this.all) {
+      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. */
+  resolve(walletId) {
+    return this.byWallet.get(walletId) ?? this.fallback;
+  }
+  async connect(input) {
+    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 });
+    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 = [];
+    for (const connector of this.all) {
+      const conns = await connector.restore().catch(() => []);
+      for (const conn of conns) {
+        this.connections.set(conn.walletId, conn);
+        restored.push(conn);
+      }
+    }
+    return restored;
+  }
+  get(walletId) {
+    return this.connections.get(walletId);
+  }
+  async disconnect(walletId) {
+    if (walletId) {
+      await this.connections.get(walletId)?.disconnect().catch(() => {
+      });
+      this.connections.delete(walletId);
+      return;
+    }
+    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()));
+  }
+  on(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  handle(event) {
+    if (event.type === "disconnect") this.connections.delete(event.walletId);
+    this.emit(event);
+  }
+  emit(event) {
+    for (const handler of this.handlers) handler(event);
+  }
+};
+
+// src/core/connector.ts
+var BaseConnector = class {
+  constructor() {
+    this.walletIds = [];
+    this.handlers = /* @__PURE__ */ new Set();
+  }
+  async restore() {
+    return [];
+  }
+  async reset() {
+  }
+  on(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  emit(event) {
+    for (const handler of this.handlers) handler(event);
+  }
+};
+
+// 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" } },
+  trust: { "scheme": "trust://wc", "universal": "https://link.trustwallet.com/wc", "store": { "ios": "https://apps.apple.com/app/apple-store/id1288339409", "android": "https://play.google.com/store/apps/details?id=com.wallet.crypto.trustapp" } },
+  rainbow: { "scheme": "rainbow://wc", "universal": "https://rnbwapp.com/wc", "store": { "ios": "https://apps.apple.com/app/apple-store/id1457119021?pt=119997837&ct=wc&mt=8", "android": "https://play.google.com/store/apps/details?id=me.rainbow&referrer=utm_source%3Dwc%26utm_medium%3Dconnector%26utm_campaign%3Dwc" } },
+  coinbase: { "store": { "ios": "https://apps.apple.com/us/app/base-formerly-coinbase-wallet/id1278383455" } },
+  zerion: { "scheme": "zerion://wc", "universal": "https://wallet.zerion.io/wc/wc", "store": { "ios": "https://apps.apple.com/app/id1456732565", "android": "https://play.google.com/store/apps/details?id=io.zerion.android&hl=en&gl=US" } },
+  tokenpocket: { "scheme": "tpoutside://wc", "store": { "ios": "https://apps.apple.com/us/app/tp-wallet/id6444625622?l=en", "android": "https://play.google.com/store/apps/details?id=vip.mytokenpocket" } },
+  blockchaincom: { "scheme": "blockchain-wallet://wc", "universal": "https://login.blockchain.com/app/wc", "store": { "ios": "https://apps.apple.com/us/app/blockchain-bitcoin-wallet/id493253309", "android": "https://play.google.com/store/apps/details?id=piuk.blockchain.android" } },
+  exodus: { "scheme": "exodus://wc", "universal": "https://exodus.com/m/wc", "store": { "ios": "https://apps.apple.com/us/app/exodus-crypto-bitcoin-wallet/id1414384820", "android": "https://play.google.com/store/apps/details?id=exodusmovement.exodus&hl=en&gl=US" } },
+  phantom: { "store": { "ios": "https://apps.apple.com/us/app/phantom-crypto-wallet/id1598432977", "android": "https://play.google.com/store/apps/details?id=app.phantom&hl=en" } },
+  okx: { "scheme": "okex://main/wc", "universal": "https://www.okx.com/download?appendQuery=true&deeplink=okx://web3/wallet/walletConnect/wc", "store": { "ios": "https://apps.apple.com/us/app/okx-buy-bitcoin-eth-crypto/id1327268470", "android": "https://play.google.com/store/apps/details?id=com.okinc.okex.gp" } },
+  cryptocom: { "scheme": "dfw://wc", "universal": "https://wallet.crypto.com/deeplink/wc", "store": { "ios": "https://apps.apple.com/US/app/id1512048310?mt=8", "android": "https://play.google.com/store/apps/details?id=com.defi.wallet" } },
+  argent: { "scheme": "argent://app/wc", "universal": "https://www.argent.xyz/app/wc", "store": { "ios": "https://apps.apple.com/us/app/argent-defi-in-a-tap/id1358741926", "android": "https://play.google.com/store/apps/details?id=im.argent.contractwalletclient&hl=en&gl=US&pli=1" } },
+  safepal: { "scheme": "safepalwallet://wc", "universal": "https://link.safepal.io/wc", "store": { "ios": "https://apps.apple.com/app/safepal-wallet/id1548297139", "android": "https://play.google.com/store/apps/details?id=io.safepal.wallet" } },
+  imtoken: { "scheme": "imtokenv2://wc", "store": { "ios": "https://apps.apple.com/us/app/imtoken2/id1384798940", "android": "https://play.google.com/store/apps/details?id=im.token.app" } },
+  ronin: { "scheme": "roninwallet://wc", "universal": "https://wallet.roninchain.com/wc", "store": { "ios": "https://apps.apple.com/us/app/ronin-wallet/id1592675001", "android": "https://play.google.com/store/apps/details?id=com.skymavis.genesis" } },
+  coin98: { "scheme": "coin98://wc", "universal": "https://coin98.com/wc", "store": { "ios": "https://apps.apple.com/vn/app/coin98-wallet/id1561969966", "android": "https://play.google.com/store/apps/details?id=coin98.crypto.finance.media&hl=vi&gl=US" } },
+  bitkeep: { "scheme": "bitkeep://wc", "universal": "https://bkapp.vip/wc", "store": { "ios": "https://web3.bitget.com/en/wallet-download?type=0", "android": "https://web3.bitget.com/en/wallet-download?type=0" } },
+  "1inch": { "scheme": "oneinch://open/nobodywilleveruseit/wc", "universal": "https://wallet.1inch.io/app/nobodywilleveruseit/wc", "store": { "ios": "https://apps.apple.com/us/app/1inch-defi-wallet/id1546049391", "android": "https://play.google.com/store/apps/details?id=io.oneinch.android" } },
+  ledgerlive: { "scheme": "ledgerlive://wc", "store": { "ios": "https://itunes.apple.com/app/id1361671700", "android": "https://play.google.com/store/apps/details?id=com.ledger.live" } },
+  atomic: { "scheme": "atomicwallet://wc", "store": { "ios": "https://apps.apple.com/us/app/atomic-wallet/id1478257827", "android": "https://play.google.com/store/apps/details?id=io.atomicwallet" } },
+  alpha: { "scheme": "awallet://wc", "universal": "https://aw.app/wc", "store": { "ios": "https://apps.apple.com/us/app/alphawallet-eth-wallet/id1358230430", "android": "https://play.google.com/store/apps/details?id=io.stormbird.wallet" } },
+  math: { "scheme": "mathwallet://wc", "universal": "https://www.mathwallet.org/wc", "store": { "ios": "https://apps.apple.com/us/app/mathwallet5/id1582612388", "android": "https://play.google.com/store/apps/details?id=com.mathwallet.android" } },
+  bitpay: { "scheme": "bitpay://wc", "universal": "https://link.bitpay.com/wc", "store": { "ios": "https://bitpay.onelink.me/Cenw/ejjaw7bs", "android": "https://bitpay.onelink.me/Cenw/ejjaw7bs" } }
+};
+
+// src/connectors/walletconnect/registry.ts
+var MANUAL_WALLET_LINKS = {
+  infinity: { scheme: "infinity://wc" }
+};
+var DEFAULT_WALLET_LINKS = {
+  ...MANUAL_WALLET_LINKS,
+  ...GENERATED_WALLET_LINKS
+};
+
+// src/connectors/walletconnect/deeplink.ts
+function isMobile() {
+  if (typeof navigator === "undefined") return false;
+  const ua = navigator.userAgent || "";
+  const uaDataMobile = navigator.userAgentData?.mobile ?? false;
+  return /iPhone|iPad|iPod|Android/i.test(ua) || uaDataMobile;
+}
+function buildLink(base, uri) {
+  const sep = base.includes("?") ? "&" : "?";
+  return `${base}${sep}uri=${encodeURIComponent(uri)}`;
+}
+function openWallet(link, uri) {
+  if (typeof document === "undefined") return;
+  if (link.universal) {
+    openHref(buildLink(link.universal, uri), true);
+  } else if (link.scheme) {
+    openHref(buildLink(link.scheme, uri), false);
+  }
+}
+function openHref(href, newContext) {
+  const a = document.createElement("a");
+  a.href = href;
+  if (newContext) {
+    a.target = "_blank";
+    a.rel = "noopener noreferrer";
+  }
+  a.style.display = "none";
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+}
+function detectAppOpen(timeoutMs) {
+  if (typeof document === "undefined") return Promise.resolve(false);
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (opened) => {
+      if (done) return;
+      done = true;
+      document.removeEventListener("visibilitychange", onVisibility);
+      window.removeEventListener("pagehide", onPageHide);
+      clearTimeout(timer);
+      resolve(opened);
+    };
+    const onVisibility = () => {
+      if (document.hidden) finish(true);
+    };
+    const onPageHide = () => finish(true);
+    document.addEventListener("visibilitychange", onVisibility);
+    window.addEventListener("pagehide", onPageHide);
+    const timer = setTimeout(() => finish(false), timeoutMs);
+  });
+}
+
+// src/connectors/walletconnect/connector.ts
+var STORAGE_KEY = "lydianconnect.wc.topics";
+var WalletConnectConnector = class extends BaseConnector {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.type = "walletconnect";
+    this.walletIds = [];
+    // claims any wallet not served by an SDK connector
+    this.client = null;
+    this.topics = /* @__PURE__ */ new Map();
+    this.warm = null;
+    this.warming = null;
+    this.links = { ...DEFAULT_WALLET_LINKS, ...config.walletLinks ?? {} };
+  }
+  isAvailable() {
+    return true;
+  }
+  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
+    });
+    client.on("session_delete", ({ topic }) => {
+      const walletId = this.walletForTopic(topic);
+      if (!walletId) return;
+      this.topics.delete(walletId);
+      this.persist();
+      this.emit({ type: "disconnect", walletId });
+    });
+    client.on("session_event", ({ topic, params }) => {
+      const walletId = this.walletForTopic(topic);
+      if (!walletId) return;
+      const { name, data } = params.event;
+      if (name === "chainChanged") {
+        const chainId = typeof data === "string" && data.includes(":") ? data : `eip155:${String(data)}`;
+        this.emit({ type: "chainChanged", walletId, chainId });
+      } else if (name === "accountsChanged" && Array.isArray(data) && data[0]) {
+        const account = String(data[0]).split(":").pop() ?? "";
+        if (account) this.emit({ type: "accountsChanged", walletId, account });
+      }
+    });
+    this.client = client;
+    this.load();
+    return client;
+  }
+  /** Pre-create a pairing so connect() can deep-link synchronously within the gesture. */
+  async warmup() {
+    if (this.warm) return;
+    if (this.warming) return this.warming;
+    this.warming = (async () => {
+      const client = await this.getClient();
+      const { topic, uri } = await client.core.pairing.create();
+      this.warm = { topic, uri };
+      this.warming = null;
+    })();
+    return this.warming;
+  }
+  async connect(req) {
+    const client = await this.getClient();
+    const reused = this.tryReuse(client, req);
+    if (reused) return reused;
+    if (!this.warm) await this.warmup();
+    const warm = this.warm;
+    this.warm = null;
+    if (!warm) throw new Error("Failed to create WalletConnect pairing");
+    this.emit({ type: "display_uri", walletId: req.walletId, uri: warm.uri });
+    if (isMobile()) {
+      const link = this.links[req.walletId];
+      if (link) {
+        openWallet(link, warm.uri);
+        void detectAppOpen(this.config.openTimeoutMs ?? 2e3).then((opened) => {
+          if (!opened) this.emit({ type: "wallet_open_failed", walletId: req.walletId, uri: warm.uri });
+        });
+      }
+    }
+    const { approval } = await client.connect({
+      pairingTopic: warm.topic,
+      optionalNamespaces: { [req.namespace.name]: req.namespace.value }
+    });
+    const session = await withSignal(approval(), req.signal, () => {
+      void client.core.pairing.disconnect({ topic: warm.topic }).catch(() => {
+      });
+    });
+    void this.warmup();
+    const connection = this.toConnection(client, req.walletId, session, req.namespace);
+    this.topics.set(req.walletId, session.topic);
+    this.persist();
+    return connection;
+  }
+  async restore() {
+    const client = await this.getClient();
+    const out = [];
+    for (const [walletId, topic] of [...this.topics]) {
+      const session = this.liveSession(client, topic);
+      if (!session) {
+        this.topics.delete(walletId);
+        continue;
+      }
+      const ns = firstNamespace(session);
+      if (ns) out.push(this.toConnection(client, walletId, session, ns));
+    }
+    this.persist();
+    return out;
+  }
+  async reset() {
+    const client = this.client;
+    if (client) {
+      await Promise.allSettled(
+        client.session.getAll().map((s) => client.disconnect({ topic: s.topic, reason: utils.getSdkError("USER_DISCONNECTED") }))
+      );
+    }
+    this.topics.clear();
+    this.persist();
+    this.warm = null;
+  }
+  // --- helpers ---
+  tryReuse(client, req) {
+    const topic = this.topics.get(req.walletId);
+    if (!topic) return null;
+    const session = this.liveSession(client, topic);
+    if (!session) {
+      this.topics.delete(req.walletId);
+      return null;
+    }
+    const ns = session.namespaces[req.namespace.name];
+    const wanted = req.namespace.value.chains?.[0];
+    if (!ns || wanted && !ns.chains?.includes(wanted)) return null;
+    return this.toConnection(client, req.walletId, session, req.namespace);
+  }
+  toConnection(client, walletId, session, namespace) {
+    const ns = session.namespaces[namespace.name];
+    const account = (ns?.accounts ?? []).map((a) => a.split(":")[2]).find((a) => !!a) ?? "";
+    const chainId = ns?.chains?.[0] ?? (ns?.accounts?.[0] ? ns.accounts[0].split(":").slice(0, 2).join(":") : `${namespace.name}:1`);
+    const topic = session.topic;
+    return {
+      walletId,
+      account,
+      chainId,
+      request: (args) => client.request({
+        topic,
+        chainId,
+        request: { method: args.method, params: args.params }
+      }),
+      disconnect: async () => {
+        await client.disconnect({ topic, reason: utils.getSdkError("USER_DISCONNECTED") }).catch(() => {
+        });
+        this.topics.delete(walletId);
+        this.persist();
+        this.emit({ type: "disconnect", walletId });
+      }
+    };
+  }
+  liveSession(client, topic) {
+    try {
+      return client.session.get(topic);
+    } catch {
+      return void 0;
+    }
+  }
+  walletForTopic(topic) {
+    for (const [walletId, t] of this.topics) if (t === topic) return walletId;
+    return null;
+  }
+  persist() {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify([...this.topics]));
+    } catch {
+    }
+  }
+  load() {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (raw) this.topics = new Map(JSON.parse(raw));
+    } catch {
+    }
+  }
+};
+function firstNamespace(session) {
+  const name = Object.keys(session.namespaces)[0];
+  if (!name) return null;
+  const v = session.namespaces[name];
+  if (!v) return null;
+  return { name, value: { chains: v.chains, methods: v.methods, events: v.events } };
+}
+function withSignal(promise, signal, onAbort) {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    onAbort();
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const abortHandler = () => {
+      onAbort();
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", abortHandler, { once: true });
+    promise.then(
+      (v) => {
+        signal.removeEventListener("abort", abortHandler);
+        resolve(v);
+      },
+      (e) => {
+        signal.removeEventListener("abort", abortHandler);
+        reject(e);
+      }
+    );
+  });
+}
+
+// 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/connectors/coinbase/connector.ts
+function rpc(provider, method, params) {
+  return provider.request({ method, params });
+}
+var WALLET_ID2 = "coinbase";
+var CoinbaseConnector = class extends BaseConnector {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.type = "sdk";
+    this.walletIds = [WALLET_ID2];
+    this.provider = null;
+    this.listenersBound = false;
+  }
+  isAvailable() {
+    return true;
+  }
+  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
+    });
+    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();
+    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"), 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}`;
+}
+
+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