@silentswap/sdk 0.1.4 → 0.1.42

package/dist/chain.d.ts

@@ -13,6 +13,19 @@ import type { Connector } from 'wagmi';
 export declare function ensureChain(chainId: number, walletClient: WalletClient, connector: Connector, options?: {
     required?: boolean;
 }): Promise<WalletClient>;
+/**
+ * Ping the WalletConnect session to ensure the relay WebSocket is alive.
+ * Browsers cannot detect stale WebSockets (no ping/pong frames), so a signing
+ * request sent on a dead socket silently vanishes. Pinging first forces
+ * the relay to reconnect if the connection dropped.
+ *
+ * @param connector - The wagmi connector (must be WalletConnect)
+ * @returns true if ping succeeded, false if it failed or connector is not WalletConnect
+ */
+export declare function pingWalletConnectSession(connector: {
+    type: string;
+    getProvider: () => Promise<unknown>;
+}): Promise<boolean>;
 /**
  * Create a public client with RPC fallback configuration
  *

package/dist/chain.js

@@ -13,6 +13,13 @@ import { H_RPCS } from './rpc.js';
  */
 export async function ensureChain(chainId, walletClient, connector, options) {
     const required = options?.required ?? true;
+    console.log('[ensureChain] called', {
+        targetChainId: chainId,
+        required,
+        connectorName: connector.name,
+        connectorType: connector.type,
+        walletClientChain: walletClient.chain?.id,
+    });
     // Check current chain
     let currentChainId;
     try {
@@ -22,35 +29,92 @@ export async function ensureChain(chainId, walletClient, connector, options) {
         // If we can't get chain ID, assume we need to switch
         currentChainId = -1;
     }
+    console.log('[ensureChain] currentChainId:', currentChainId, 'targetChainId:', chainId, 'needsSwitch:', currentChainId !== chainId);
     if (currentChainId !== chainId) {
+        let switchSucceeded = false;
         try {
             // Try to switch chain
+            console.log('[ensureChain] attempting switchChain ...', { hasSwitchChain: !!connector.switchChain });
             await connector.switchChain?.({ chainId });
+            switchSucceeded = true;
+            console.log('[ensureChain] switchChain succeeded');
         }
         catch (switchError) {
+            console.warn('[ensureChain] switchChain failed', {
+                error: switchError instanceof Error ? switchError.message : switchError,
+                required,
+            });
             if (required) {
                 throw new Error(`Failed to switch to chain ${chainId}`);
             }
             // Non-required: chain switch failed (e.g. Trust Wallet via WalletConnect
-            // doesn't support programmatic chain switching). Return the original client
-            // — signTypedData works regardless of the active chain since chainId is
-            // part of the signed EIP-712 data, not a prerequisite for signing.
-            return walletClient;
+            // doesn't support programmatic chain switching). Still recreate the
+            // walletClient from the provider so the WalletConnect transport is fresh
+            // — TrustWallet silently drops signTypedData when the client's chain scope
+            // doesn't match its active session chain.
         }
-        // After chain switch, create a fresh walletClient bound to the new chain.
+        // Always recreate walletClient from the provider after a chain change attempt.
         // Critical for WalletConnect: the old walletClient's chain scope (e.g. eip155:43114)
-        // doesn't match the new active chain, so signing requests get silently dropped
-        // by the mobile wallet.
+        // doesn't match the active chain, so signing requests get silently dropped
+        // by the mobile wallet. This applies both after a successful switch AND a failed
+        // one — the provider's internal state may still have updated even if switchChain threw.
+        console.log('[ensureChain] recreating walletClient from provider ...', { switchSucceeded });
         const provider = await connector.getProvider();
         const chain = getChainById(chainId);
-        return createWalletClient({
+        const newClient = createWalletClient({
             account: walletClient.account,
             chain,
             transport: custom(provider),
         });
+        console.log('[ensureChain] new walletClient created', {
+            chainId: newClient.chain?.id,
+            account: newClient.account?.address,
+        });
+        return newClient;
     }
+    console.log('[ensureChain] already on correct chain, returning existing walletClient');
     return walletClient;
 }
+/**
+ * Ping the WalletConnect session to ensure the relay WebSocket is alive.
+ * Browsers cannot detect stale WebSockets (no ping/pong frames), so a signing
+ * request sent on a dead socket silently vanishes. Pinging first forces
+ * the relay to reconnect if the connection dropped.
+ *
+ * @param connector - The wagmi connector (must be WalletConnect)
+ * @returns true if ping succeeded, false if it failed or connector is not WalletConnect
+ */
+export async function pingWalletConnectSession(connector) {
+    if (connector.type !== 'walletConnect')
+        return true; // Not WC, nothing to ping
+    try {
+        const provider = await connector.getProvider();
+        const topic = provider?.session?.topic;
+        // Try both paths: Reown (provider.client) and legacy WC (provider.signer.client)
+        const signClient = provider?.client?.ping ? provider.client : provider?.signer?.client;
+        if (!topic || !signClient?.ping) {
+            console.log('[pingWC] no session or sign client, skipping ping', {
+                hasTopic: !!topic,
+                hasClient: !!provider?.client,
+                hasClientPing: !!provider?.client?.ping,
+                hasSigner: !!provider?.signer,
+                hasSignerClient: !!provider?.signer?.client,
+            });
+            return true; // Can't ping, assume ok
+        }
+        console.log('[pingWC] pinging session ...');
+        await Promise.race([
+            signClient.ping({ topic }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('WC ping timeout')), 5000)),
+        ]);
+        console.log('[pingWC] ping OK');
+        return true;
+    }
+    catch (err) {
+        console.warn('[pingWC] ping failed, session may be stale:', err.message);
+        return false;
+    }
+}
 /**
  * Create a public client with RPC fallback configuration
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/sdk",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.42",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [