@lydianpay/lydianconnect 1.1.4 → 1.2.0

package/dist/index.cjs

@@ -36,18 +36,23 @@ var ConnectManager = class {
     }
   }
   /**
-   * SDK connector if one claims this walletId AND serves the requested
-   * namespace, else the fallback. So an EVM-only SDK connector is bypassed to
-   * WalletConnect for a non-EVM chain. The host app is oblivious.
+   * The connector claiming this walletId if it serves the requested namespace
+   * AND is currently available, else the fallback. So an EVM-only SDK connector
+   * is bypassed to WalletConnect for a non-EVM chain, and the injected connector
+   * is bypassed when the wallet's extension hasn't announced a provider. The host
+   * app is oblivious. SDK connectors report `isAvailable` synchronously as `true`,
+   * so this only awaits for connectors that actually probe (e.g. injected).
    */
-  resolve(walletId, namespaceName) {
+  async resolve(walletId, namespaceName) {
     const claimed = this.byWallet.get(walletId);
-    if (claimed && claimed.servesNamespace(namespaceName)) return claimed;
+    if (claimed && claimed.servesNamespace(namespaceName) && await claimed.isAvailable(walletId))
+      return claimed;
     return this.fallback;
   }
   async connect(req) {
     if (!this.started) await this.init();
-    const connection = await this.resolve(req.walletId, req.namespace.name).connect(req);
+    const connector = await this.resolve(req.walletId, req.namespace.name);
+    const connection = await connector.connect(req);
     this.connections.set(req.walletId, connection);
     this.emit({ type: "connect", walletId: req.walletId, connection });
     return connection;
@@ -132,6 +137,100 @@ function buildNamespace(chainId) {
   };
 }
 
+// node_modules/@lydianpay/lydianconnect-catalog/dist/index.js
+var ICON_BASE = "https://wallet-assets.lydian.com/wallets";
+var WALLETS = [
+  { id: "metamask", name: "MetaMask", namespaces: ["eip155"] },
+  { id: "trust", name: "Trust", namespaces: ["eip155", "solana"] },
+  { id: "rainbow", name: "Rainbow", namespaces: ["eip155"] },
+  { id: "coinbase", name: "Coinbase", namespaces: ["eip155", "solana"] },
+  { id: "zerion", name: "Zerion", namespaces: ["eip155"] },
+  { id: "tokenpocket", name: "Token Pocket", namespaces: ["eip155", "solana"] },
+  { id: "blockchaincom", name: "Blockchain.com", namespaces: ["bip122", "eip155", "solana"] },
+  { id: "exodus", name: "Exodus", namespaces: ["eip155", "solana"] },
+  { id: "phantom", name: "Phantom", namespaces: ["bip122", "eip155", "solana"] },
+  { id: "okx", name: "OKX", namespaces: ["bip122", "eip155", "solana"] },
+  { id: "cryptocom", name: "Crypto.com", namespaces: ["bip122", "eip155", "solana"] },
+  { id: "argent", name: "Argent", namespaces: ["eip155"] },
+  { id: "safepal", name: "SafePal", namespaces: ["eip155", "solana", "ton"] },
+  { id: "imtoken", name: "imToken", namespaces: ["eip155"] },
+  { id: "ronin", name: "Ronin", namespaces: ["eip155"] },
+  { id: "coin98", name: "Coin98", namespaces: ["eip155", "solana"] },
+  { id: "bitkeep", name: "Bitget Wallet", namespaces: ["eip155", "solana"] },
+  { id: "1inch", name: "1inch", namespaces: ["eip155", "solana"] },
+  { id: "ledgerlive", name: "Ledger Live", namespaces: ["bip122", "eip155", "solana"] },
+  { id: "atomic", name: "Atomic", namespaces: ["bip122", "eip155", "solana"] },
+  { id: "alpha", name: "Alpha", namespaces: ["eip155"] },
+  { id: "math", name: "Math", namespaces: ["eip155", "solana"] },
+  { id: "bitpay", name: "BitPay", namespaces: ["eip155"] },
+  { id: "rabby", name: "Rabby", namespaces: ["eip155"] },
+  { id: "bybit", name: "Bybit", namespaces: ["eip155", "solana"] },
+  { id: "binance", name: "Binance", namespaces: ["eip155", "solana"] },
+  { id: "gate", name: "Gate Wallet", namespaces: ["eip155"] },
+  { id: "core", name: "Core", namespaces: ["eip155", "solana"] },
+  { id: "backpack", name: "Backpack", namespaces: ["eip155", "solana"] },
+  { id: "frontier", name: "Frontier", namespaces: ["eip155"] },
+  { id: "onekey", name: "OneKey", namespaces: ["eip155"] },
+  { id: "kraken", name: "Kraken", namespaces: ["eip155", "solana"] },
+  { id: "uniswap", name: "Uniswap Wallet", namespaces: ["eip155"] },
+  { id: "omni", name: "Omni", namespaces: ["eip155"] },
+  { id: "mew", name: "MEW Wallet", namespaces: ["eip155"] },
+  { id: "foxwallet", name: "FoxWallet", namespaces: ["eip155"] },
+  { id: "nova", name: "Nova Wallet", namespaces: ["eip155"] },
+  { id: "subwallet", name: "SubWallet", namespaces: ["eip155"] },
+  { id: "safe", name: "Safe", namespaces: ["eip155"] },
+  { id: "robinhood", name: "Robinhood Wallet", namespaces: ["eip155"] },
+  { id: "tangem", name: "Tangem", namespaces: ["eip155", "solana"] },
+  { id: "trezor", name: "Trezor", namespaces: ["bip122", "eip155", "solana"] },
+  { id: "kucoin", name: "KuCoin", namespaces: ["eip155", "solana"] },
+  { id: "jupiter", name: "Jupiter", namespaces: ["solana"] },
+  { id: "zengo", name: "Zengo", namespaces: ["eip155"] },
+  { id: "bitcoincom", name: "Bitcoin.com", namespaces: ["eip155"] },
+  { id: "keplr", name: "Keplr", namespaces: ["eip155"] },
+  { id: "cake", name: "Cake Wallet", namespaces: ["eip155", "solana"] },
+  { id: "unstoppable", name: "Unstoppable", namespaces: ["eip155"] },
+  { id: "bifrost", name: "Bifrost", namespaces: ["bip122", "eip155"] },
+  { id: "pintu", name: "Pintu", namespaces: ["eip155"] },
+  { id: "hot", name: "HOT Wallet", namespaces: ["eip155", "solana"] },
+  { id: "arculus", name: "Arculus", namespaces: ["bip122", "eip155", "solana"] }
+];
+var EXTENSIONS = {
+  metamask: {
+    rdns: "io.metamask",
+    extensionUrl: "https://chromewebstore.google.com/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn"
+  },
+  trust: {
+    rdns: "com.trustwallet.app",
+    extensionUrl: "https://chromewebstore.google.com/detail/trust-wallet/egjidjbpglichdcondbcbdnbeeppgdph"
+  },
+  rabby: {
+    rdns: "io.rabby",
+    extensionUrl: "https://chromewebstore.google.com/detail/rabby-wallet/acmacodkjbdgmoleebolmdjonilkdbch"
+  },
+  okx: {
+    // Legacy "okex" brand retained in the extension's rdns after the 2022 rebrand.
+    rdns: "com.okex.wallet",
+    extensionUrl: "https://chromewebstore.google.com/detail/okx-wallet/mcohilncbfahbmgdjkbpemcciiolgcge"
+  },
+  phantom: {
+    rdns: "app.phantom",
+    extensionUrl: "https://chromewebstore.google.com/detail/phantom/bfnaelmomeimhlpmgjnjophhpkkoljpa"
+  },
+  zerion: {
+    rdns: "io.zerion",
+    extensionUrl: "https://chromewebstore.google.com/detail/zerion-wallet-crypto-defi/klghhnkeealcohjjanjjdaeeggmfmlpl"
+  },
+  rainbow: {
+    rdns: "me.rainbow",
+    extensionUrl: "https://chromewebstore.google.com/detail/rainbow/opfgelmcmbiajamepnmloijbpoleiama"
+  }
+};
+var WALLET_CATALOG = WALLETS.map((w) => ({
+  ...w,
+  iconUrl: `${ICON_BASE}/${w.id}.png`,
+  ...EXTENSIONS[w.id] ?? {}
+}));
+
 // src/core/connector.ts
 var BaseConnector = class {
   constructor() {
@@ -388,6 +487,159 @@ function evmChainIds(req) {
   return Number.isFinite(n) && n > 0 ? [n] : void 0;
 }
 
+// src/connectors/injected/connector.ts
+var DISCOVERY_WAIT_MS = 100;
+var InjectedConnector = class extends BaseConnector {
+  constructor(rdnsByWallet) {
+    super();
+    this.rdnsByWallet = rdnsByWallet;
+    this.type = "injected";
+    /** rdns -> the provider it announced. Populated by EIP-6963 discovery. */
+    this.discovered = /* @__PURE__ */ new Map();
+    /**
+     * Providers we've already attached listeners to. Bind once and keep for the
+     * page's life (never remove) so a reconnect doesn't stack duplicate listeners.
+     * EIP-6963 announces exactly one provider per rdns, so a given provider maps to
+     * a single walletId — closing over walletId in bindEvents is safe.
+     */
+    this.bound = /* @__PURE__ */ new WeakSet();
+    this.listening = false;
+    this.walletIds = Object.keys(rdnsByWallet);
+    this.startDiscovery();
+  }
+  /** Listen for provider announcements, then ask installed extensions to announce. */
+  startDiscovery() {
+    if (this.listening || typeof window === "undefined") return;
+    this.listening = true;
+    window.addEventListener("eip6963:announceProvider", (event) => {
+      const detail = event.detail;
+      if (detail?.info?.rdns && detail.provider) this.discovered.set(detail.info.rdns, detail);
+    });
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+  }
+  servesNamespace(name) {
+    return name === "eip155";
+  }
+  /** Available iff the wallet's extension has announced an injected provider. */
+  async isAvailable(walletId) {
+    if (typeof window === "undefined") return false;
+    const rdns = this.rdnsByWallet[walletId];
+    if (!rdns) return false;
+    if (this.discovered.has(rdns)) return true;
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+    await new Promise((resolve) => setTimeout(resolve, DISCOVERY_WAIT_MS));
+    return this.discovered.has(rdns);
+  }
+  async connect(req) {
+    const provider = this.providerFor(req.walletId);
+    if (!provider) throw new Error(`No injected provider announced for "${req.walletId}"`);
+    const accounts = await withSignal(
+      provider.request({ method: "eth_requestAccounts" }),
+      // triggers the extension popup
+      req.signal
+    );
+    const account = accounts?.[0];
+    if (!account) throw new Error(`${req.walletId} extension returned no account`);
+    await this.ensureChain(provider, req);
+    const chainId = toCaip3(await provider.request({ method: "eth_chainId" }));
+    this.bindEvents(provider, req.walletId);
+    return this.toConnection(provider, req.walletId, account, chainId);
+  }
+  async restore() {
+    if (typeof window === "undefined") return [];
+    if (this.discovered.size === 0) {
+      window.dispatchEvent(new Event("eip6963:requestProvider"));
+      await new Promise((resolve) => setTimeout(resolve, DISCOVERY_WAIT_MS));
+    }
+    const out = [];
+    for (const walletId of this.walletIds) {
+      const provider = this.providerFor(walletId);
+      if (!provider) continue;
+      const accounts = await provider.request({ method: "eth_accounts" }).catch(() => []);
+      const account = accounts?.[0];
+      if (!account) continue;
+      const chainId = toCaip3(
+        await provider.request({ method: "eth_chainId" }).catch(() => "0x1")
+      );
+      this.bindEvents(provider, walletId);
+      out.push(this.toConnection(provider, walletId, account, chainId));
+    }
+    return out;
+  }
+  providerFor(walletId) {
+    const rdns = this.rdnsByWallet[walletId];
+    return rdns ? this.discovered.get(rdns)?.provider : void 0;
+  }
+  bindEvents(provider, walletId) {
+    if (this.bound.has(provider)) return;
+    this.bound.add(provider);
+    provider.on("chainChanged", (hex) => {
+      this.emit({ type: "chainChanged", walletId, chainId: toCaip3(String(hex)) });
+    });
+    provider.on("accountsChanged", (accounts) => {
+      const account = Array.isArray(accounts) ? accounts[0] : void 0;
+      if (account) this.emit({ type: "accountsChanged", walletId, account });
+      else this.emit({ type: "disconnect", walletId });
+    });
+    provider.on("disconnect", () => this.emit({ type: "disconnect", walletId }));
+  }
+  /** 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, walletId, account, chainId) {
+    return {
+      walletId,
+      account,
+      chainId,
+      request: async (args) => await provider.request({ method: args.method, params: args.params }),
+      openWallet: () => {
+      },
+      // the extension foregrounds its own popup on request
+      disconnect: async () => {
+        await provider.request({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] }).catch(() => {
+        });
+        this.emit({ type: "disconnect", walletId });
+      }
+    };
+  }
+};
+function toCaip3(hexChainId) {
+  if (!hexChainId) return "eip155:1";
+  const num = hexChainId.startsWith("0x") ? parseInt(hexChainId, 16) : Number(hexChainId);
+  return `eip155:${Number.isFinite(num) ? num : 1}`;
+}
+function withSignal(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new DOMException("Aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+
 // src/connectors/walletconnect/wallet-links.ts
 var WALLET_LINKS = {
   metamask: { "native": "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" } },
@@ -586,7 +838,7 @@ var WalletConnectConnector = class extends BaseConnector {
       }
     }
     const pairingTopic = utils.parseUri(uri).topic;
-    const session = await withSignal(approval(), req.signal, () => {
+    const session = await withSignal2(approval(), req.signal, () => {
       void client.core.pairing.disconnect({ topic: pairingTopic }).catch(() => {
       });
     });
@@ -694,7 +946,7 @@ function firstNamespace(session) {
   if (!v) return null;
   return { name, value: { chains: v.chains, methods: v.methods, events: v.events } };
 }
-function withSignal(promise, signal, onAbort) {
+function withSignal2(promise, signal, onAbort) {
   if (!signal) return promise;
   if (signal.aborted) {
     onAbort();
@@ -720,15 +972,24 @@ function withSignal(promise, signal, onAbort) {
 }
 
 // src/core/lydian-connect.ts
+function injectedRdnsMap(sdkServed) {
+  const map = {};
+  for (const w of WALLET_CATALOG) {
+    if (w.rdns && w.namespaces.includes("eip155") && !sdkServed.has(w.id)) map[w.id] = w.rdns;
+  }
+  return map;
+}
 function createConnectors(config) {
   const app = {
     appName: config.appName,
     icon: config.icon,
     description: config.description
   };
+  const sdk = [new MetaMaskConnector(app), new CoinbaseConnector(app)];
+  const sdkServed = new Set(sdk.flatMap((c) => c.walletIds));
   return [
-    new MetaMaskConnector(app),
-    new CoinbaseConnector(app),
+    ...sdk,
+    new InjectedConnector(injectedRdnsMap(sdkServed)),
     new WalletConnectConnector(app, { projectId: config.walletConnectProjectId })
   ];
 }