@lydianpay/lydianconnect 1.2.1 → 1.4.0

package/README.md

@@ -43,6 +43,8 @@ lc.on((event) => {
 
 `connect({ walletId, chainId })` — `chainId` is the chain the user is paying on (a number like `137`, or a CAIP-2 id like `'eip155:137'`).
 
+The WalletConnect client also advertises a return link derived from the page URL (origin + path, no query/hash); wallets may use it to bring the user back to the page after a deep-link approval.
+
 ## Supported wallets
 
 The canonical list of supported wallets lives in

package/dist/index.cjs

@@ -72,6 +72,14 @@ var ConnectManager = class {
   get(walletId) {
     return this.connections.get(walletId);
   }
+  /**
+   * Fire a wallet's deep link. Goes straight to the fallback: it is the only
+   * connector that owns a link table, and the only one that emits the
+   * `display_uri` a host is responding to when it calls this.
+   */
+  openWallet(input) {
+    return this.fallback.openWallet?.(input) ?? false;
+  }
   async disconnect(walletId) {
     if (walletId) {
       await this.connections.get(walletId)?.disconnect().catch(() => {
@@ -244,10 +252,15 @@ var WALLET_CATALOG = WALLETS.map((w) => ({
 }));
 
 // src/core/connector.ts
+function requestedChain(req) {
+  return req.namespace.value.chains?.[0];
+}
 var BaseConnector = class {
   constructor() {
     this.walletIds = [];
     this.handlers = /* @__PURE__ */ new Set();
+    /** Depth of in-flight connects; see {@link duringConnect}. */
+    this.connecting = 0;
   }
   servesNamespace(_namespaceName) {
     return true;
@@ -261,7 +274,28 @@ var BaseConnector = class {
     this.handlers.add(handler);
     return () => this.handlers.delete(handler);
   }
+  /**
+   * Run a connect with its handshake events suppressed.
+   *
+   * A connector that binds provider listeners before requesting accounts sees the
+   * wallet's own setup traffic — an initial `chainChanged`, and another when
+   * `ensureChain` switches. Forwarding those makes the host believe the user moved
+   * networks mid-connect. Nothing is lost by dropping them: connect() reads the
+   * authoritative account and chain when it settles, and only changes made after
+   * that are the user's.
+   */
+  async duringConnect(run) {
+    this.connecting++;
+    try {
+      return await run();
+    } finally {
+      this.connecting--;
+    }
+  }
   emit(event) {
+    if (this.connecting > 0 && (event.type === "chainChanged" || event.type === "accountsChanged")) {
+      return;
+    }
     for (const handler of this.handlers) handler(event);
   }
 };
@@ -270,6 +304,84 @@ var BaseConnector = class {
 function deriveUrl() {
   return typeof window !== "undefined" ? window.location.origin : "";
 }
+function deriveRedirectUrl() {
+  if (typeof window === "undefined") return "";
+  return window.location.origin + window.location.pathname;
+}
+
+// src/connectors/eip155/chain.ts
+var CHAIN_SETTLE = { timeoutMs: 4e3, intervalMs: 100 };
+function toCaip(chainId) {
+  if (!chainId) return "eip155:1";
+  const num = chainId.startsWith("0x") ? parseInt(chainId, 16) : Number(chainId);
+  return `eip155:${Number.isFinite(num) ? num : 1}`;
+}
+async function currentChain(rpc2) {
+  const raw = await rpc2({ method: "eth_chainId" }).catch(() => null);
+  return toCaip(typeof raw === "string" ? raw : null);
+}
+async function settleChain({
+  rpc: rpc2,
+  chainId,
+  timeoutMs,
+  intervalMs
+}) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const actual = await currentChain(rpc2);
+    if (actual === chainId || Date.now() >= deadline) return;
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+async function ensureChain({
+  rpc: rpc2,
+  chainId,
+  timeoutMs = CHAIN_SETTLE.timeoutMs,
+  intervalMs = CHAIN_SETTLE.intervalMs
+}) {
+  const chainNumber = chainId ? Number(chainId.split(":")[1]) : NaN;
+  if (!Number.isFinite(chainNumber) || chainNumber <= 0) return;
+  const requested = `eip155:${chainNumber}`;
+  if (await currentChain(rpc2) === requested) return;
+  const switched = await rpc2({
+    method: "wallet_switchEthereumChain",
+    params: [{ chainId: `0x${chainNumber.toString(16)}` }]
+  }).then(
+    () => true,
+    // Chain not added to the wallet, or the user declined — the caller's
+    // chainChanged will reflect reality. No settle: the chain isn't moving.
+    () => false
+  );
+  if (switched) {
+    await settleChain({ rpc: rpc2, chainId: requested, timeoutMs, intervalMs });
+  }
+}
+
+// src/core/abort.ts
+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(
+      (value) => {
+        signal.removeEventListener("abort", abortHandler);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", abortHandler);
+        reject(error);
+      }
+    );
+  });
+}
 
 // src/connectors/metamask/connector.ts
 var WALLET_ID = "metamask";
@@ -328,17 +440,23 @@ var MetaMaskConnector = class extends BaseConnector {
     );
   }
   async connect(req) {
-    const provider = await this.getProvider();
-    const accounts = await provider.request({
-      method: "eth_requestAccounts"
+    return this.duringConnect(async () => {
+      const provider = await this.getProvider();
+      const accounts = await withSignal(
+        provider.request({ method: "eth_requestAccounts" }),
+        req.signal
+      );
+      const account = accounts?.[0];
+      if (!account) throw new Error("MetaMask returned no account");
+      await ensureChain({
+        rpc: rpcFor(provider),
+        chainId: requestedChain(req)
+      });
+      const chainId = toCaip(
+        await provider.request({ method: "eth_chainId" })
+      );
+      return this.toConnection(provider, account, chainId);
     });
-    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);
@@ -356,22 +474,6 @@ var MetaMaskConnector = class extends BaseConnector {
     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,
@@ -393,20 +495,18 @@ var MetaMaskConnector = class extends BaseConnector {
     };
   }
 };
-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}`;
+function rpcFor(provider) {
+  return (args) => provider.request(args);
 }
 
 // src/connectors/coinbase/connector.ts
+var WALLET_ID2 = "coinbase";
 function rpc(provider, method, params) {
   return provider.request({
     method,
     params
   });
 }
-var WALLET_ID2 = "coinbase";
 var CoinbaseConnector = class extends BaseConnector {
   constructor(app) {
     super();
@@ -443,7 +543,7 @@ var CoinbaseConnector = class extends BaseConnector {
       this.emit({
         type: "chainChanged",
         walletId: WALLET_ID2,
-        chainId: toCaip2(String(hex))
+        chainId: toCaip(String(hex))
       });
     });
     provider.on("accountsChanged", (accounts) => {
@@ -458,13 +558,18 @@ var CoinbaseConnector = class extends BaseConnector {
     );
   }
   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);
+    return this.duringConnect(async () => {
+      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 ensureChain({
+        rpc: rpcFor2(provider),
+        chainId: requestedChain(req)
+      });
+      const chainId = toCaip(await rpc(provider, "eth_chainId"));
+      return this.toConnection(provider, account, chainId);
+    });
   }
   async restore() {
     const provider = await this.getProvider().catch(() => null);
@@ -474,7 +579,7 @@ var CoinbaseConnector = class extends BaseConnector {
     );
     const account = accounts?.[0];
     if (!account) return [];
-    const chainId = toCaip2(
+    const chainId = toCaip(
       await rpc(provider, "eth_chainId").catch(() => "0x1")
     );
     return [this.toConnection(provider, account, chainId)];
@@ -485,20 +590,6 @@ var CoinbaseConnector = class extends BaseConnector {
     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,
@@ -518,10 +609,8 @@ var CoinbaseConnector = class extends BaseConnector {
     };
   }
 };
-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 rpcFor2(provider) {
+  return ({ method, params }) => rpc(provider, method, params);
 }
 function evmChainIds(req) {
   const wanted = req.namespace.value.chains?.[0];
@@ -585,8 +674,8 @@ var InjectedConnector = class extends BaseConnector {
     const account = accounts?.[0];
     if (!account)
       throw new Error(`${req.walletId} extension returned no account`);
-    await this.ensureChain(provider, req);
-    const chainId = toCaip3(
+    await ensureChain({ rpc: rpcFor3(provider), chainId: requestedChain(req) });
+    const chainId = toCaip(
       await provider.request({ method: "eth_chainId" })
     );
     this.bindEvents(provider, req.walletId);
@@ -605,7 +694,7 @@ var InjectedConnector = class extends BaseConnector {
       const accounts = await provider.request({ method: "eth_accounts" }).catch(() => []);
       const account = accounts?.[0];
       if (!account) continue;
-      const chainId = toCaip3(
+      const chainId = toCaip(
         await provider.request({ method: "eth_chainId" }).catch(() => "0x1")
       );
       this.bindEvents(provider, walletId);
@@ -624,7 +713,7 @@ var InjectedConnector = class extends BaseConnector {
       this.emit({
         type: "chainChanged",
         walletId,
-        chainId: toCaip3(String(hex))
+        chainId: toCaip(String(hex))
       });
     });
     provider.on("accountsChanged", (accounts) => {
@@ -637,22 +726,6 @@ var InjectedConnector = class extends BaseConnector {
       () => 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,
@@ -676,29 +749,8 @@ var InjectedConnector = class extends BaseConnector {
     };
   }
 };
-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);
-      }
-    );
-  });
+function rpcFor3(provider) {
+  return (args) => provider.request(args);
 }
 
 // src/connectors/walletconnect/wallet-links.ts
@@ -1148,13 +1200,15 @@ 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.scheme) {
-    openHref(buildLink(link.scheme, uri));
-  } else if (link.universal) {
-    openHref(buildLink(link.universal, uri));
-  }
+function canOpen(link) {
+  return !!(link?.scheme || link?.universal);
+}
+function openWallet(link, uri, via = "scheme") {
+  if (typeof document === "undefined") return false;
+  const base = via === "universal" ? link.universal : link.scheme ?? link.universal;
+  if (!base) return false;
+  openHref(buildLink(base, uri));
+  return true;
 }
 function openWalletApp(link) {
   if (typeof document === "undefined") return;
@@ -1193,6 +1247,7 @@ function detectAppOpen(timeoutMs) {
 
 // src/connectors/walletconnect/connector.ts
 var STORAGE_KEY = "lydianconnect.wc.topics";
+var PING_TIMEOUT_MS = 3e3;
 var WalletConnectConnector = class extends BaseConnector {
   constructor(app, options) {
     super();
@@ -1203,6 +1258,9 @@ var WalletConnectConnector = class extends BaseConnector {
     // claims any wallet not served by an SDK connector
     this.client = null;
     this.topics = /* @__PURE__ */ new Map();
+    /** walletId -> pairing URI of the connect currently awaiting approval, so a
+     *  host-driven open button can fire without the host tracking the URI itself. */
+    this.pending = /* @__PURE__ */ new Map();
     this.links = { ...DEFAULT_WALLET_LINKS, ...options.walletLinks ?? {} };
   }
   isAvailable() {
@@ -1210,13 +1268,16 @@ var WalletConnectConnector = class extends BaseConnector {
   }
   async getClient() {
     if (this.client) return this.client;
+    const redirectUrl = deriveRedirectUrl();
     const client = await SignClient__default.default.init({
       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] : []
+        icons: this.app.icon ? [this.app.icon] : [],
+        // Wallets may use this to return the user after deep-link approvals.
+        ...redirectUrl ? { redirect: { universal: redirectUrl } } : {}
       },
       relayUrl: this.options.relayUrl
     });
@@ -1246,35 +1307,37 @@ var WalletConnectConnector = class extends BaseConnector {
   }
   async connect(req) {
     const client = await this.getClient();
-    const reused = this.tryReuse(client, req);
+    const reused = await this.tryReuse(client, req);
     if (reused) return reused;
     const { uri, approval } = await client.connect({
       requiredNamespaces: { [req.namespace.name]: req.namespace.value }
     });
     if (!uri) throw new Error("WalletConnect did not return a pairing URI");
-    this.emit({ type: "display_uri", walletId: req.walletId, uri });
-    if (isMobile()) {
-      const link = this.links[req.walletId];
-      if (link) {
-        openWallet(link, uri);
-        void detectAppOpen(this.options.openTimeoutMs ?? 2e3).then(
-          (opened) => {
-            if (!opened)
-              this.emit({
-                type: "wallet_open_failed",
-                walletId: req.walletId,
-                uri,
-                store: link.store
-              });
-          }
-        );
-      }
+    const link = isMobile() ? this.links[req.walletId] : void 0;
+    this.emit({
+      type: "display_uri",
+      walletId: req.walletId,
+      uri,
+      deepLink: canOpen(link)
+    });
+    if (link && canOpen(link)) {
+      this.pending.set(req.walletId, uri);
+      openWallet(link, uri);
+      void detectAppOpen(this.options.openTimeoutMs ?? 2e3).then((opened) => {
+        if (!opened)
+          this.emit({
+            type: "wallet_open_failed",
+            walletId: req.walletId,
+            uri,
+            store: link.store
+          });
+      });
     }
     const pairingTopic = utils.parseUri(uri).topic;
-    const session = await withSignal2(approval(), req.signal, () => {
+    const session = await withSignal(approval(), req.signal, () => {
       void client.core.pairing.disconnect({ topic: pairingTopic }).catch(() => {
       });
-    });
+    }).finally(() => this.pending.delete(req.walletId));
     const connection = this.toConnection(
       client,
       req.walletId,
@@ -1285,11 +1348,30 @@ var WalletConnectConnector = class extends BaseConnector {
     this.persist();
     return connection;
   }
+  /**
+   * Fire a wallet's deep link on demand. The host calls this from a real click,
+   * which is the one context a mobile browser reliably allows a scheme
+   * navigation from — see the note on {@link openWallet}.
+   */
+  openWallet(input) {
+    const link = this.links[input.walletId];
+    if (!link) return false;
+    const uri = input.uri ?? this.pending.get(input.walletId);
+    if (!uri) {
+      openWalletApp(link);
+      return !!link.native;
+    }
+    return openWallet(link, uri, input.via ?? "scheme");
+  }
   async restore() {
     const client = await this.getClient();
+    const checked = await Promise.all(
+      [...this.topics].map(
+        async ([walletId, topic]) => [walletId, await this.liveSession(client, topic)]
+      )
+    );
     const out = [];
-    for (const [walletId, topic] of [...this.topics]) {
-      const session = this.liveSession(client, topic);
+    for (const [walletId, session] of checked) {
       if (!session) {
         this.topics.delete(walletId);
         continue;
@@ -1313,15 +1395,17 @@ var WalletConnectConnector = class extends BaseConnector {
       );
     }
     this.topics.clear();
+    this.pending.clear();
     this.persist();
   }
   // --- helpers ---
-  tryReuse(client, req) {
+  async tryReuse(client, req) {
     const topic = this.topics.get(req.walletId);
     if (!topic) return null;
-    const session = this.liveSession(client, topic);
+    const session = await this.liveSession(client, topic);
     if (!session) {
       this.topics.delete(req.walletId);
+      this.persist();
       return null;
     }
     const ns = session.namespaces[req.namespace.name];
@@ -1332,7 +1416,9 @@ var WalletConnectConnector = class extends BaseConnector {
   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 approved = ns?.chains?.length ? ns.chains : (ns?.accounts ?? []).map((a) => a.split(":").slice(0, 2).join(":"));
+    const wanted = namespace.value.chains?.[0];
+    const chainId = wanted && approved.includes(wanted) ? wanted : approved[0] ?? `${namespace.name}:1`;
     const topic = session.topic;
     return {
       walletId,
@@ -1357,12 +1443,27 @@ var WalletConnectConnector = class extends BaseConnector {
       }
     };
   }
-  liveSession(client, topic) {
+  /**
+   * A stored session the wallet is still on the other end of. The local record
+   * is not evidence — it survives the user clearing the dApp inside their
+   * wallet — and reusing a dead one returns a Connection that looks healthy
+   * while every request hangs. So the peer has to answer for it.
+   */
+  async liveSession(client, topic) {
+    let session;
     try {
-      return client.session.get(topic);
+      session = client.session.get(topic);
     } catch {
       return void 0;
     }
+    let timer;
+    const alive = await Promise.race([
+      client.ping({ topic }).then(() => true).catch(() => false),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), PING_TIMEOUT_MS);
+      })
+    ]).finally(() => clearTimeout(timer));
+    return alive ? session : void 0;
   }
   walletForTopic(topic) {
     for (const [walletId, t] of this.topics) if (t === topic) return walletId;
@@ -1393,30 +1494,6 @@ function firstNamespace(session) {
     value: { chains: v.chains, methods: v.methods, events: v.events }
   };
 }
-function withSignal2(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/core/lydian-connect.ts
 function injectedRdnsMap(sdkServed) {
@@ -1462,6 +1539,20 @@ var LydianConnect = class {
       signal: input.signal
     });
   }
+  /**
+   * Open a wallet app, optionally handing it the pairing URI from `display_uri`.
+   *
+   * Call this from a real click handler. A mobile browser will suppress the same
+   * navigation issued automatically after an async step, which is why the
+   * `display_uri` event reports `deepLink` — that is the library asking the host
+   * for a button to put this behind.
+   *
+   * Returns whether a link was fired. `false` means nothing is known for this
+   * wallet on this device; show the QR code instead.
+   */
+  openWallet(input) {
+    return this.manager.openWallet(input);
+  }
   restore() {
     return this.manager.restore();
   }