@aurum-sdk/core 0.2.0 → 0.2.2-canary.0

package/dist/index.mjs

@@ -1,22 +1,19 @@
 import {
-  AppKitAdapter,
   ConnectPages,
   ConnectUIProviders,
   DEFAULT_THEME,
   Modal,
   ThemeContainer,
-  WalletConnectAdapter,
   createConfigError,
   generateCompleteStyles,
   getDefaultThemeConfig,
   initSentry,
-  isMobile,
   sentryLogger,
   sortWallets,
   useAurumStore,
   useNavigation,
   waitForStoreHydration
-} from "./chunk-NRC534B3.mjs";
+} from "./chunk-THE7QLMS.mjs";
 
 // src/AurumCore.ts
 import { checksumAddress } from "viem";
@@ -103,7 +100,6 @@ function createModalContainer(id, brandConfig) {
 }
 
 // src/components/ConnectModal/renderConnectModal.tsx
-import { WalletId } from "@aurum-sdk/types";
 import { jsx as jsx2 } from "react/jsx-runtime";
 var CONTAINER_ID = "aurum-modal-container";
 function renderConnectModal({
@@ -111,11 +107,7 @@ function renderConnectModal({
   brandConfig
 }) {
   return new Promise((resolve, reject) => {
-    let sortedWallets = sortWallets(displayedWallets, { filterHidden: false });
-    const hasAppKit = sortedWallets.some((w) => w instanceof AppKitAdapter);
-    if (isMobile() && !hasAppKit) {
-      sortedWallets = sortedWallets.filter((w) => w.id !== WalletId.WalletConnect);
-    }
+    const sortedWallets = sortWallets(displayedWallets, { filterHidden: false });
     const { root, cleanup } = createModalContainer(CONTAINER_ID, brandConfig);
     const onConnect = (result) => {
       cleanup();
@@ -133,13 +125,13 @@ function renderConnectModal({
 
 // src/wallet-adapters/RabbyAdapter.ts
 import { getLogoDataUri } from "@aurum-sdk/logos";
-import { WalletId as WalletId2, WalletName } from "@aurum-sdk/types";
+import { WalletId, WalletName } from "@aurum-sdk/types";
 var RABBY_RDNS = "io.rabby";
 var RabbyAdapter = class {
   constructor() {
-    this.id = WalletId2.Rabby;
+    this.id = WalletId.Rabby;
     this.name = WalletName.Rabby;
-    this.icon = getLogoDataUri(WalletId2.Rabby, "brand") ?? "";
+    this.icon = getLogoDataUri(WalletId.Rabby, "brand") ?? "";
     this.hide = false;
     this.downloadUrl = "https://rabby.io";
     this.wcDeepLinkUrl = null;
@@ -191,7 +183,7 @@ var RabbyAdapter = class {
     return null;
   }
   isInstalled() {
-    return Boolean(this.provider);
+    return Boolean(this.provider ?? this.detectLegacyProvider());
   }
   async connect() {
     if (!this.provider && this.providerPromise) {
@@ -201,27 +193,23 @@ var RabbyAdapter = class {
       sentryLogger.error("Rabby is not available");
       throw new Error("Rabby is not available");
     }
-    try {
-      await this.provider.request({
-        method: "wallet_requestPermissions",
-        params: [{ eth_accounts: {} }]
-      });
-      const accounts = await this.provider.request({
-        method: "eth_requestAccounts",
-        params: []
-      });
-      if (!accounts || accounts.length === 0 || !accounts[0]) {
-        sentryLogger.error("No accounts returned from Rabby");
-        throw new Error("No accounts returned from Rabby");
-      }
-      return {
-        address: accounts[0],
-        provider: this.provider,
-        walletId: this.id
-      };
-    } catch {
-      throw new Error("Failed to connect to Rabby");
+    await this.provider.request({
+      method: "wallet_requestPermissions",
+      params: [{ eth_accounts: {} }]
+    });
+    const accounts = await this.provider.request({
+      method: "eth_requestAccounts",
+      params: []
+    });
+    if (!accounts || accounts.length === 0 || !accounts[0]) {
+      sentryLogger.error("No accounts returned from Rabby");
+      throw new Error("No accounts returned from Rabby");
     }
+    return {
+      address: accounts[0],
+      provider: this.provider,
+      walletId: this.id
+    };
   }
   async tryRestoreConnection() {
     if (!this.provider && this.providerPromise) {
@@ -271,7 +259,7 @@ var RabbyAdapter = class {
 
 // src/wallet-adapters/BraveAdapter.ts
 import { getLogoDataUri as getLogoDataUri2 } from "@aurum-sdk/logos";
-import { WalletId as WalletId3, WalletName as WalletName2 } from "@aurum-sdk/types";
+import { WalletId as WalletId2, WalletName as WalletName2 } from "@aurum-sdk/types";
 
 // src/utils/platform/isBraveBrowser.ts
 function isBraveBrowser() {
@@ -283,9 +271,9 @@ function isBraveBrowser() {
 var BRAVE_RDNS = "com.brave.wallet";
 var BraveAdapter = class {
   constructor() {
-    this.id = WalletId3.Brave;
+    this.id = WalletId2.Brave;
     this.name = WalletName2.Brave;
-    this.icon = getLogoDataUri2(WalletId3.Brave, "brand") ?? "";
+    this.icon = getLogoDataUri2(WalletId2.Brave, "brand") ?? "";
     this.downloadUrl = "https://brave.com/download";
     this.wcDeepLinkUrl = null;
     this.provider = null;
@@ -341,7 +329,7 @@ var BraveAdapter = class {
     return null;
   }
   isInstalled() {
-    return Boolean(this.provider);
+    return Boolean(this.provider ?? this.detectLegacyProvider());
   }
   async connect() {
     if (!this.provider && this.providerPromise) {
@@ -351,27 +339,23 @@ var BraveAdapter = class {
       sentryLogger.error("Brave Wallet is not available");
       throw new Error("Brave Wallet is not available");
     }
-    try {
-      await this.provider.request({
-        method: "wallet_requestPermissions",
-        params: [{ eth_accounts: {} }]
-      });
-      const accounts = await this.provider.request({
-        method: "eth_requestAccounts",
-        params: []
-      });
-      if (!accounts || accounts.length === 0 || !accounts[0]) {
-        sentryLogger.error("No accounts returned from Brave Wallet");
-        throw new Error("No accounts returned from Brave Wallet");
-      }
-      return {
-        address: accounts[0],
-        provider: this.provider,
-        walletId: this.id
-      };
-    } catch {
-      throw new Error("Failed to connect to Brave Wallet");
+    await this.provider.request({
+      method: "wallet_requestPermissions",
+      params: [{ eth_accounts: {} }]
+    });
+    const accounts = await this.provider.request({
+      method: "eth_requestAccounts",
+      params: []
+    });
+    if (!accounts || accounts.length === 0 || !accounts[0]) {
+      sentryLogger.error("No accounts returned from Brave Wallet");
+      throw new Error("No accounts returned from Brave Wallet");
     }
+    return {
+      address: accounts[0],
+      provider: this.provider,
+      walletId: this.id
+    };
   }
   async tryRestoreConnection() {
     if (!this.provider && this.providerPromise) {
@@ -419,132 +403,15 @@ var BraveAdapter = class {
   }
 };
 
-// src/wallet-adapters/LedgerAdapter.ts
-import { getLogoDataUri as getLogoDataUri3 } from "@aurum-sdk/logos";
-import { WalletId as WalletId4, WalletName as WalletName3 } from "@aurum-sdk/types";
-import { SupportedProviders } from "@ledgerhq/connect-kit-loader";
-import { mainnet } from "viem/chains";
-var LedgerAdapter = class {
-  constructor(config) {
-    this.id = WalletId4.Ledger;
-    this.name = WalletName3.Ledger;
-    this.icon = getLogoDataUri3(WalletId4.Ledger, "brand") ?? "";
-    this.hide = false;
-    this.downloadUrl = "https://www.ledger.com/ledger-live";
-    this.wcDeepLinkUrl = "ledgerlive://wc?uri=";
-    this.provider = null;
-    this.accountsChangedCallback = null;
-    this.walletConnectProjectId = config?.walletConnectProjectId;
-  }
-  isInstalled() {
-    return true;
-  }
-  async connect() {
-    try {
-      if (!this.walletConnectProjectId) {
-        throw createConfigError("Ledger");
-      }
-      const { loadConnectKit } = await import("@ledgerhq/connect-kit-loader");
-      const connectKit = await loadConnectKit();
-      connectKit.enableDebugLogs();
-      connectKit.checkSupport({
-        providerType: SupportedProviders.Ethereum,
-        chainId: 1,
-        walletConnectVersion: 2,
-        projectId: this.walletConnectProjectId,
-        rpc: { 1: mainnet.rpcUrls.default.http[0] }
-      });
-      this.provider = await connectKit.getProvider();
-      if (!this.provider) {
-        sentryLogger.error("Failed to get Ledger provider");
-        throw new Error("Failed to get Ledger provider");
-      }
-      const accounts = await this.provider.request({
-        method: "eth_requestAccounts",
-        params: []
-      });
-      if (!accounts || accounts.length === 0 || !accounts[0]) {
-        sentryLogger.error("No accounts returned from Ledger");
-        throw new Error("No accounts returned from Ledger");
-      }
-      return {
-        address: accounts[0],
-        provider: this.provider,
-        walletId: this.id
-      };
-    } catch {
-      throw new Error("Failed to connect to Ledger");
-    }
-  }
-  async tryRestoreConnection() {
-    try {
-      const { loadConnectKit } = await import("@ledgerhq/connect-kit-loader");
-      const connectKit = await loadConnectKit();
-      connectKit.checkSupport({
-        providerType: SupportedProviders.Ethereum,
-        chainId: 1,
-        walletConnectVersion: 2,
-        projectId: this.walletConnectProjectId,
-        rpc: { 1: mainnet.rpcUrls.default.http[0] }
-      });
-      this.provider = await connectKit.getProvider();
-      if (!this.provider) {
-        return null;
-      }
-      const accounts = await this.provider.request({
-        method: "eth_accounts",
-        params: []
-      });
-      if (!accounts || accounts.length === 0 || !accounts[0]) {
-        return null;
-      }
-      return {
-        address: accounts[0],
-        provider: this.provider,
-        walletId: this.id
-      };
-    } catch {
-      return null;
-    }
-  }
-  async disconnect() {
-    try {
-      const provider = this.provider;
-      if (provider?.disconnect) {
-        await provider.disconnect();
-      }
-      this.provider = null;
-    } catch (error) {
-      sentryLogger.warn("Failed to disconnect from Ledger", { error });
-    }
-  }
-  getProvider() {
-    return this.provider;
-  }
-  onAccountsChanged(callback) {
-    if (!this.provider?.on) return;
-    if (this.accountsChangedCallback) {
-      this.provider.removeListener?.("accountsChanged", this.accountsChangedCallback);
-    }
-    this.accountsChangedCallback = callback;
-    this.provider.on("accountsChanged", this.accountsChangedCallback);
-  }
-  removeListeners() {
-    if (!this.provider?.removeListener || !this.accountsChangedCallback) return;
-    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
-    this.accountsChangedCallback = null;
-  }
-};
-
 // src/wallet-adapters/PhantomAdapter.ts
-import { getLogoDataUri as getLogoDataUri4 } from "@aurum-sdk/logos";
-import { WalletId as WalletId5, WalletName as WalletName4 } from "@aurum-sdk/types";
+import { getLogoDataUri as getLogoDataUri3 } from "@aurum-sdk/logos";
+import { WalletId as WalletId3, WalletName as WalletName3 } from "@aurum-sdk/types";
 var PHANTOM_RDNS = "app.phantom";
 var PhantomAdapter = class {
   constructor() {
-    this.id = WalletId5.Phantom;
-    this.name = WalletName4.Phantom;
-    this.icon = getLogoDataUri4(WalletId5.Phantom, "brand") ?? "";
+    this.id = WalletId3.Phantom;
+    this.name = WalletName3.Phantom;
+    this.icon = getLogoDataUri3(WalletId3.Phantom, "brand") ?? "";
     this.hide = false;
     this.downloadUrl = "https://phantom.com/download";
     this.wcDeepLinkUrl = "phantom://wc?uri=";
@@ -601,7 +468,7 @@ var PhantomAdapter = class {
     return null;
   }
   isInstalled() {
-    return Boolean(this.provider);
+    return Boolean(this.provider ?? this.detectLegacyProvider());
   }
   async connect() {
     if (!this.provider && this.providerPromise) {
@@ -611,27 +478,23 @@ var PhantomAdapter = class {
       sentryLogger.error("Phantom is not available");
       throw new Error("Phantom is not available");
     }
-    try {
-      await this.provider.request({
-        method: "wallet_requestPermissions",
-        params: [{ eth_accounts: {} }]
-      });
-      const accounts = await this.provider.request({
-        method: "eth_requestAccounts",
-        params: []
-      });
-      if (!accounts || accounts.length === 0 || !accounts[0]) {
-        sentryLogger.error("No accounts returned from Phantom");
-        throw new Error("No accounts returned from Phantom");
-      }
-      return {
-        address: accounts[0],
-        provider: this.provider,
-        walletId: this.id
-      };
-    } catch {
-      throw new Error("Failed to connect to Phantom");
+    await this.provider.request({
+      method: "wallet_requestPermissions",
+      params: [{ eth_accounts: {} }]
+    });
+    const accounts = await this.provider.request({
+      method: "eth_requestAccounts",
+      params: []
+    });
+    if (!accounts || accounts.length === 0 || !accounts[0]) {
+      sentryLogger.error("No accounts returned from Phantom");
+      throw new Error("No accounts returned from Phantom");
     }
+    return {
+      address: accounts[0],
+      provider: this.provider,
+      walletId: this.id
+    };
   }
   async tryRestoreConnection() {
     if (!this.provider && this.providerPromise) {
@@ -681,26 +544,34 @@ var PhantomAdapter = class {
 
 // src/wallet-adapters/CoinbaseWalletAdapter.ts
 import { createCoinbaseWalletSDK } from "@coinbase/wallet-sdk";
-import { getLogoDataUri as getLogoDataUri5 } from "@aurum-sdk/logos";
-import { WalletId as WalletId6, WalletName as WalletName5 } from "@aurum-sdk/types";
+import { getLogoDataUri as getLogoDataUri4 } from "@aurum-sdk/logos";
+import { WalletId as WalletId4, WalletName as WalletName4 } from "@aurum-sdk/types";
 var CoinbaseWalletAdapter = class {
-  constructor({ appName, appLogoUrl }) {
-    this.id = WalletId6.CoinbaseWallet;
-    this.name = WalletName5.CoinbaseWallet;
-    this.icon = getLogoDataUri5(WalletId6.CoinbaseWallet, "brand") ?? "";
+  constructor({ appName, appLogoUrl, telemetry }) {
+    this.id = WalletId4.CoinbaseWallet;
+    this.name = WalletName4.CoinbaseWallet;
+    this.icon = getLogoDataUri4(WalletId4.CoinbaseWallet, "brand") ?? "";
     this.hide = false;
     this.downloadUrl = "https://www.coinbase.com/wallet/downloads";
     this.wcDeepLinkUrl = "cbwallet://wc?uri=";
     this.provider = null;
     this.accountsChangedCallback = null;
-    this.provider = this.detectProvider({ appName, appLogoUrl });
+    this.provider = this.detectProvider({ appName, appLogoUrl, telemetry: telemetry ?? false });
   }
-  detectProvider({ appName, appLogoUrl }) {
+  detectProvider({
+    appName,
+    appLogoUrl,
+    telemetry
+  }) {
     if (typeof window === "undefined") return null;
     try {
       const coinbaseSdk = createCoinbaseWalletSDK({
         appName,
-        appLogoUrl
+        appLogoUrl,
+        preference: {
+          options: "all",
+          telemetry
+        }
       });
       return coinbaseSdk.getProvider();
     } catch (error) {
@@ -716,23 +587,19 @@ var CoinbaseWalletAdapter = class {
       sentryLogger.error("Coinbase Wallet is not available");
       throw new Error("Coinbase Wallet is not available");
     }
-    try {
-      const accounts = await this.provider.request({
-        method: "eth_requestAccounts",
-        params: []
-      });
-      if (!accounts || accounts.length === 0 || !accounts[0]) {
-        sentryLogger.error("No accounts returned from Coinbase Wallet");
-        throw new Error("No accounts returned from Coinbase Wallet");
-      }
-      return {
-        address: accounts[0],
-        provider: this.provider,
-        walletId: this.id
-      };
-    } catch {
-      throw new Error("Failed to connect to Coinbase Wallet");
+    const accounts = await this.provider.request({
+      method: "eth_requestAccounts",
+      params: []
+    });
+    if (!accounts || accounts.length === 0 || !accounts[0]) {
+      sentryLogger.error("No accounts returned from Coinbase Wallet");
+      throw new Error("No accounts returned from Coinbase Wallet");
     }
+    return {
+      address: accounts[0],
+      provider: this.provider,
+      walletId: this.id
+    };
   }
   async tryRestoreConnection() {
     if (!this.isInstalled() || !this.provider) {
@@ -802,14 +669,14 @@ var CoinbaseWalletAdapter = class {
 };
 
 // src/wallet-adapters/MetaMaskAdapter.ts
-import { getLogoDataUri as getLogoDataUri6 } from "@aurum-sdk/logos";
-import { WalletId as WalletId7, WalletName as WalletName6 } from "@aurum-sdk/types";
+import { getLogoDataUri as getLogoDataUri5 } from "@aurum-sdk/logos";
+import { WalletId as WalletId5, WalletName as WalletName5 } from "@aurum-sdk/types";
 var METAMASK_RDNS = "io.metamask";
 var MetaMaskAdapter = class {
   constructor() {
-    this.id = WalletId7.MetaMask;
-    this.name = WalletName6.MetaMask;
-    this.icon = getLogoDataUri6(WalletId7.MetaMask, "brand") ?? "";
+    this.id = WalletId5.MetaMask;
+    this.name = WalletName5.MetaMask;
+    this.icon = getLogoDataUri5(WalletId5.MetaMask, "brand") ?? "";
     this.hide = false;
     this.downloadUrl = "https://metamask.io/download";
     this.wcDeepLinkUrl = "metamask://wc?uri=";
@@ -867,7 +734,7 @@ var MetaMaskAdapter = class {
     return null;
   }
   isInstalled() {
-    return Boolean(this.provider);
+    return Boolean(this.provider ?? this.detectLegacyProvider());
   }
   async connect() {
     if (!this.provider && this.providerPromise) {
@@ -877,27 +744,23 @@ var MetaMaskAdapter = class {
       sentryLogger.error("MetaMask is not available");
       throw new Error("MetaMask is not available");
     }
-    try {
-      await this.provider.request({
-        method: "wallet_requestPermissions",
-        params: [{ eth_accounts: {} }]
-      });
-      const accounts = await this.provider.request({
-        method: "eth_requestAccounts",
-        params: []
-      });
-      if (!accounts || accounts.length === 0 || !accounts[0]) {
-        sentryLogger.error("No accounts returned from MetaMask");
-        throw new Error("No accounts returned from MetaMask");
-      }
-      return {
-        address: accounts[0],
-        provider: this.provider,
-        walletId: this.id
-      };
-    } catch {
-      throw new Error("Failed to connect to MetaMask");
+    await this.provider.request({
+      method: "wallet_requestPermissions",
+      params: [{ eth_accounts: {} }]
+    });
+    const accounts = await this.provider.request({
+      method: "eth_requestAccounts",
+      params: []
+    });
+    if (!accounts || accounts.length === 0 || !accounts[0]) {
+      sentryLogger.error("No accounts returned from MetaMask");
+      throw new Error("No accounts returned from MetaMask");
     }
+    return {
+      address: accounts[0],
+      provider: this.provider,
+      walletId: this.id
+    };
   }
   async tryRestoreConnection() {
     if (!this.provider && this.providerPromise) {
@@ -945,14 +808,538 @@ var MetaMaskAdapter = class {
   }
 };
 
+// src/wallet-adapters/WalletConnectAdapter.ts
+import { getLogoDataUri as getLogoDataUri6 } from "@aurum-sdk/logos";
+import { WalletId as WalletId6, WalletName as WalletName6 } from "@aurum-sdk/types";
+
+// src/constants/adapters.ts
+var WALLETCONNECT_NAMESPACE = {
+  eip155: {
+    methods: [
+      // Transaction methods
+      "eth_sendTransaction",
+      "eth_signTransaction",
+      "eth_sendRawTransaction",
+      // Signing methods
+      "eth_sign",
+      "personal_sign",
+      "eth_signTypedData",
+      "eth_signTypedData_v3",
+      "eth_signTypedData_v4",
+      // Account methods
+      "eth_accounts",
+      "eth_requestAccounts",
+      // Chain management
+      "wallet_switchEthereumChain",
+      "wallet_addEthereumChain",
+      // Permissions (EIP-2255)
+      "wallet_requestPermissions",
+      "wallet_getPermissions"
+    ],
+    chains: [
+      // Ethereum
+      "eip155:1",
+      // Mainnet
+      "eip155:11155111",
+      // Sepolia
+      // Base
+      "eip155:8453",
+      // Mainnet
+      "eip155:84532",
+      // Sepolia
+      // Optimism
+      "eip155:10",
+      // Mainnet
+      "eip155:11155420",
+      // Sepolia
+      // Arbitrum
+      "eip155:42161",
+      // Mainnet
+      "eip155:421614",
+      // Sepolia
+      // BNB Chain
+      "eip155:56",
+      // Mainnet
+      "eip155:97",
+      // Testnet
+      // Polygon
+      "eip155:137",
+      // Mainnet
+      "eip155:80002",
+      // Amoy
+      // Fantom
+      "eip155:250",
+      // Mainnet
+      "eip155:4002",
+      // Testnet
+      // Linea
+      "eip155:59144",
+      // Mainnet
+      "eip155:59141",
+      // Sepolia
+      // Gnosis
+      "eip155:100",
+      // Mainnet
+      "eip155:10200",
+      // Chiado
+      // Polygon zkEVM
+      "eip155:1101",
+      // Mainnet
+      "eip155:2442",
+      // Cardona
+      // Avalanche C-Chain
+      "eip155:43114",
+      // Mainnet
+      "eip155:43113"
+      // Fuji
+    ],
+    events: ["chainChanged", "accountsChanged"]
+  }
+};
+
+// src/wallet-adapters/WalletConnectAdapter.ts
+function extractAddressFromSession(namespaces) {
+  const accounts = namespaces?.eip155?.accounts || [];
+  const firstAccount = accounts[0];
+  return firstAccount?.split(":")[2] ?? null;
+}
+var WalletConnectAdapter = class {
+  constructor(config) {
+    this.id = WalletId6.WalletConnect;
+    this.name = WalletName6.WalletConnect;
+    this.icon = getLogoDataUri6(WalletId6.WalletConnect, "brand") ?? "";
+    this.hide = false;
+    this.downloadUrl = null;
+    this.wcDeepLinkUrl = null;
+    this.modal = null;
+    this.wagmiAdapter = null;
+    this.universalProvider = null;
+    this.provider = null;
+    this.address = null;
+    this.connectionUri = null;
+    this.accountsChangedCallback = null;
+    this.chainChangedCallback = null;
+    this.disconnectCallback = null;
+    this.sessionUpdateHandler = null;
+    this.unsubscribeFunctions = [];
+    this.initPromise = null;
+    this.lastKnownAccounts = [];
+    this.lastKnownChainId = null;
+    this.config = config;
+  }
+  async ensureInitialized() {
+    if (this.modal) return;
+    if (!this.initPromise) {
+      this.initPromise = this.initializeAppKit();
+    }
+    await this.initPromise;
+  }
+  async initializeAppKit() {
+    if (typeof window === "undefined") return;
+    const [{ createAppKit }, { WagmiAdapter }, { mainnet }] = await Promise.all([
+      import("@reown/appkit"),
+      import("@reown/appkit-adapter-wagmi"),
+      import("@reown/appkit/networks")
+    ]);
+    const networks = [mainnet];
+    this.wagmiAdapter = new WagmiAdapter({
+      projectId: this.config.projectId,
+      networks,
+      ssr: true
+    });
+    this.modal = createAppKit({
+      adapters: [this.wagmiAdapter],
+      networks,
+      projectId: this.config.projectId,
+      metadata: {
+        name: this.config.appName,
+        description: this.config.appName,
+        url: window.location.origin,
+        icons: []
+      },
+      allowUnsupportedChain: true,
+      themeMode: this.config.theme,
+      themeVariables: {
+        "--apkt-z-index": this.config.modalZIndex + 1
+      },
+      features: {
+        analytics: this.config.telemetry ?? false
+      }
+    });
+    this.universalProvider = await this.modal.getUniversalProvider() ?? null;
+    this.setupEventListeners();
+  }
+  setupEventListeners() {
+    if (!this.modal) return;
+    const unsubscribeProviders = this.modal.subscribeProviders((state) => {
+      const eip155Provider = state["eip155"];
+      this.provider = eip155Provider || null;
+      if (!eip155Provider) {
+        this.address = null;
+      }
+    });
+    this.unsubscribeFunctions.push(unsubscribeProviders);
+    if (this.universalProvider) {
+      this.universalProvider.on("display_uri", (uri) => {
+        this.connectionUri = uri;
+        if (typeof window !== "undefined") {
+          window.dispatchEvent(new CustomEvent("walletconnect:uri", { detail: { uri } }));
+        }
+      });
+      this.universalProvider.on("session_delete", () => {
+        this.handleRemoteDisconnect();
+      });
+      this.universalProvider.on("session_expire", () => {
+        this.handleRemoteDisconnect();
+      });
+    }
+  }
+  /** Called when user disconnects from the wallet side (mobile app) */
+  handleRemoteDisconnect() {
+    this.connectionUri = null;
+    this.address = null;
+    this.provider = null;
+    this.lastKnownAccounts = [];
+    this.lastKnownChainId = null;
+    if (this.accountsChangedCallback) {
+      this.accountsChangedCallback([]);
+    }
+    if (this.disconnectCallback) {
+      this.disconnectCallback();
+    }
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent("walletconnect:disconnect"));
+    }
+  }
+  syncAddressFromWagmi() {
+    if (!this.wagmiAdapter?.wagmiConfig) return;
+    const { state } = this.wagmiAdapter.wagmiConfig;
+    if (state.current && state.connections) {
+      const connection = state.connections.get(state.current);
+      if (connection?.accounts?.[0]) {
+        this.address = connection.accounts[0];
+      }
+    }
+  }
+  async syncProviderFromModal() {
+    if (!this.modal) return;
+    try {
+      const getProvidersFn = this.modal.getProviders;
+      if (typeof getProvidersFn === "function") {
+        const providers = getProvidersFn.call(this.modal);
+        const eip155Provider = providers?.["eip155"];
+        if (eip155Provider) {
+          this.provider = eip155Provider;
+          return;
+        }
+      }
+      if (this.wagmiAdapter?.wagmiConfig) {
+        const { state } = this.wagmiAdapter.wagmiConfig;
+        if (state.current && state.connections) {
+          const connection = state.connections.get(state.current);
+          const connector = connection?.connector;
+          if (connector && typeof connector.getProvider === "function") {
+            try {
+              const provider = await connector.getProvider();
+              if (provider) {
+                this.provider = provider;
+              }
+            } catch (error) {
+              sentryLogger.warn("Failed to get provider from wagmi connector", { error });
+            }
+          }
+        }
+      }
+    } catch (error) {
+      sentryLogger.warn("Failed to get provider from WalletConnect", { error });
+    }
+  }
+  isInstalled() {
+    return true;
+  }
+  getConnectionUri() {
+    return this.connectionUri;
+  }
+  /** Resets connection state for a fresh connection flow */
+  async resetConnectionState() {
+    this.connectionUri = null;
+    this.address = null;
+    this.lastKnownAccounts = [];
+    this.lastKnownChainId = null;
+    try {
+      const { state } = this.wagmiAdapter?.wagmiConfig || {};
+      const connection = state?.current && state.connections?.get(state.current);
+      if (connection && typeof connection !== "string" && connection.connector?.disconnect) {
+        await connection.connector.disconnect();
+      }
+    } catch {
+    }
+    if (this.modal?.getIsConnectedState()) {
+      try {
+        await this.modal.disconnect("eip155");
+      } catch {
+      }
+    }
+    if (this.universalProvider?.session) {
+      try {
+        await this.universalProvider.disconnect();
+      } catch {
+      }
+    }
+    await new Promise((r) => setTimeout(r, 200));
+    this.provider = null;
+  }
+  /**
+   * Connects via WalletConnect QR code flow.
+   * Emits walletconnect:uri event for QR code display.
+   */
+  async connect() {
+    if (!this.config.projectId) throw createConfigError("WalletConnect");
+    await this.ensureInitialized();
+    if (!this.universalProvider) throw new Error("WalletConnect is not available");
+    await this.resetConnectionState();
+    try {
+      const session = await this.universalProvider.connect({ namespaces: WALLETCONNECT_NAMESPACE });
+      if (!session) throw new Error("Failed to establish WalletConnect session");
+      const address = extractAddressFromSession(session.namespaces);
+      if (!address) throw new Error("No accounts returned from WalletConnect");
+      this.provider = this.universalProvider;
+      this.address = address;
+      this.lastKnownAccounts = [address];
+      return { address, provider: this.provider, walletId: this.id };
+    } catch (error) {
+      this.connectionUri = null;
+      throw error;
+    }
+  }
+  /**
+   * Starts a WalletConnect session for headless/custom QR code flows.
+   * Returns the URI immediately and a function to wait for the connection.
+   */
+  async startSession(timeout = 1e4) {
+    if (!this.config.projectId) throw new Error("WalletConnect projectId is required");
+    await this.ensureInitialized();
+    if (!this.universalProvider) throw new Error("WalletConnect is not available");
+    await this.resetConnectionState();
+    const uriPromise = new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => reject(new Error("Timeout waiting for WalletConnect URI")), timeout);
+      this.universalProvider.once("display_uri", (uri2) => {
+        clearTimeout(timeoutId);
+        this.connectionUri = uri2;
+        resolve(uri2);
+      });
+    });
+    const connectionPromise = (async () => {
+      const session = await this.universalProvider.connect({ namespaces: WALLETCONNECT_NAMESPACE });
+      if (!session) throw new Error("Failed to establish WalletConnect session");
+      const address = extractAddressFromSession(session.namespaces);
+      if (!address) throw new Error("No accounts returned from WalletConnect");
+      this.provider = this.universalProvider;
+      this.address = address;
+      this.lastKnownAccounts = [address];
+      return { address, provider: this.provider, walletId: this.id };
+    })();
+    const uri = await uriPromise;
+    return {
+      uri,
+      waitForConnection: async () => {
+        try {
+          return await connectionPromise;
+        } catch (error) {
+          this.connectionUri = null;
+          throw error;
+        }
+      }
+    };
+  }
+  /**
+   * Opens the AppKit modal for wallet selection.
+   * Used on mobile and when user clicks "Open Modal" button.
+   */
+  async openModal() {
+    if (!this.config.projectId) throw createConfigError("WalletConnect");
+    await this.ensureInitialized();
+    if (!this.modal) throw new Error("AppKit is not available");
+    await this.resetConnectionState();
+    this.modal.open({ view: "AllWallets" });
+    return this.waitForModalConnection();
+  }
+  waitForModalConnection(timeout = 6e4) {
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let unsubscribe = null;
+      let resolved = false;
+      const cleanup = () => unsubscribe?.();
+      const checkConnection = async () => {
+        if (resolved) return true;
+        this.syncAddressFromWagmi();
+        if (this.address && !this.provider) await this.syncProviderFromModal();
+        if (this.provider && this.address) {
+          try {
+            const accounts = await this.provider.request({ method: "eth_accounts" });
+            if (accounts?.length) {
+              resolved = true;
+              cleanup();
+              this.modal?.close();
+              this.lastKnownAccounts = accounts;
+              resolve({ address: this.address, provider: this.provider, walletId: this.id });
+              return true;
+            }
+          } catch {
+          }
+        }
+        return false;
+      };
+      unsubscribe = this.modal.subscribeState(async (state) => {
+        if (await checkConnection()) return;
+        if (!state.open && !this.address && !resolved) {
+          cleanup();
+          reject(new Error("Connection rejected by user"));
+        }
+      });
+      const poll = async () => {
+        if (await checkConnection()) return;
+        if (Date.now() - startTime > timeout) {
+          cleanup();
+          reject(new Error("Connection timeout"));
+          return;
+        }
+        setTimeout(poll, 500);
+      };
+      poll();
+    });
+  }
+  async tryRestoreConnection() {
+    await this.ensureInitialized();
+    if (!this.wagmiAdapter) return null;
+    try {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const { state } = this.wagmiAdapter.wagmiConfig || {};
+      const connection = state?.current && state.connections?.get(state.current);
+      if (!connection || typeof connection === "string") return null;
+      const address = connection.accounts?.[0];
+      if (address && this.provider) {
+        this.address = address;
+        this.lastKnownAccounts = [...connection.accounts || []];
+        return { address, provider: this.provider, walletId: this.id };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async disconnect() {
+    if (this.modal) {
+      await this.modal.disconnect("eip155");
+      const deadline = Date.now() + 2e3;
+      while (Date.now() < deadline && (this.modal.getIsConnectedState() || this.modal.getAddress())) {
+        await new Promise((r) => setTimeout(r, 100));
+      }
+    }
+    this.address = null;
+    this.provider = null;
+    this.connectionUri = null;
+    this.lastKnownAccounts = [];
+    this.lastKnownChainId = null;
+  }
+  getProvider() {
+    return this.provider;
+  }
+  onAccountsChanged(callback) {
+    if (this.accountsChangedCallback && this.provider?.removeListener) {
+      this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    }
+    if (this.sessionUpdateHandler && this.universalProvider?.removeListener) {
+      this.universalProvider.removeListener("session_update", this.sessionUpdateHandler);
+    }
+    if (!this.lastKnownAccounts.length && this.address) this.lastKnownAccounts = [this.address];
+    this.accountsChangedCallback = (accounts) => {
+      this.address = accounts[0] || null;
+      this.lastKnownAccounts = accounts;
+      callback(accounts);
+    };
+    if (this.provider?.on) {
+      this.provider.on("accountsChanged", this.accountsChangedCallback);
+    }
+    if (this.universalProvider?.on) {
+      this.sessionUpdateHandler = (args) => {
+        const accounts = this.extractAccountsFromNamespaces(args?.params?.namespaces);
+        if (accounts.length && this.hasAccountsChanged(accounts)) {
+          this.lastKnownAccounts = accounts;
+          this.address = accounts[0];
+          callback(accounts);
+        }
+      };
+      this.universalProvider.on("session_update", this.sessionUpdateHandler);
+    }
+  }
+  onChainChanged(callback) {
+    if (!this.provider?.on) return;
+    if (this.chainChangedCallback) this.provider.removeListener?.("chainChanged", this.chainChangedCallback);
+    this.chainChangedCallback = (chainId) => {
+      const normalized = typeof chainId === "string" ? chainId : `0x${Number(chainId).toString(16)}`;
+      if (normalized !== this.lastKnownChainId) {
+        this.lastKnownChainId = normalized;
+        callback(normalized);
+      }
+    };
+    this.provider.on("chainChanged", this.chainChangedCallback);
+  }
+  /** Called when remote wallet disconnects (user disconnects from mobile app) */
+  onDisconnect(callback) {
+    this.disconnectCallback = callback;
+  }
+  /** Updates the AppKit modal theme */
+  updateTheme(theme) {
+    this.config.theme = theme;
+    if (this.modal && typeof this.modal.setThemeMode === "function") {
+      this.modal.setThemeMode(theme);
+    }
+  }
+  extractAccountsFromNamespaces(namespaces) {
+    if (!namespaces) return [];
+    const accounts = [];
+    Object.values(namespaces).forEach((ns) => {
+      ns?.accounts?.forEach((account) => {
+        const address = account.split(":")[2];
+        if (address) accounts.push(address);
+      });
+    });
+    return [...new Set(accounts)];
+  }
+  hasAccountsChanged(newAccounts) {
+    if (newAccounts.length !== this.lastKnownAccounts.length) return true;
+    return newAccounts.some((acc, i) => acc.toLowerCase() !== this.lastKnownAccounts[i]?.toLowerCase());
+  }
+  removeListeners() {
+    if (this.accountsChangedCallback) {
+      this.provider?.removeListener?.("accountsChanged", this.accountsChangedCallback);
+      this.accountsChangedCallback = null;
+    }
+    if (this.chainChangedCallback) {
+      this.provider?.removeListener?.("chainChanged", this.chainChangedCallback);
+      this.chainChangedCallback = null;
+    }
+    if (this.sessionUpdateHandler) {
+      this.universalProvider?.removeListener?.("session_update", this.sessionUpdateHandler);
+      this.sessionUpdateHandler = null;
+    }
+    this.disconnectCallback = null;
+    this.unsubscribeFunctions.forEach((unsub) => unsub());
+    this.unsubscribeFunctions = [];
+    this.lastKnownAccounts = [];
+    this.lastKnownChainId = null;
+  }
+};
+
 // src/wallet-adapters/EmailAdapter.ts
-import { WalletId as WalletId8, WalletName as WalletName7 } from "@aurum-sdk/types";
+import { WalletId as WalletId7, WalletName as WalletName7 } from "@aurum-sdk/types";
 import { getLogoDataUri as getLogoDataUri7 } from "@aurum-sdk/logos";
 var _EmailAdapter = class _EmailAdapter {
   constructor(config) {
-    this.id = WalletId8.Email;
+    this.id = WalletId7.Email;
     this.name = WalletName7.Email;
-    this.icon = getLogoDataUri7(WalletId8.Email, "brand") ?? "";
+    this.icon = getLogoDataUri7(WalletId7.Email, "brand") ?? "";
     this.hide = true;
     this.downloadUrl = null;
     this.wcDeepLinkUrl = null;
@@ -960,6 +1347,7 @@ var _EmailAdapter = class _EmailAdapter {
     this.initPromise = null;
     this.publicClientCache = /* @__PURE__ */ new Map();
     this.projectId = config?.projectId || "";
+    this.telemetry = config?.telemetry ?? false;
   }
   async ensureInitialized() {
     if (this.provider) return;
@@ -1081,7 +1469,8 @@ var _EmailAdapter = class _EmailAdapter {
       projectId: this.projectId,
       ethereum: {
         createOnLogin: "eoa"
-      }
+      },
+      disableAnalytics: !this.telemetry
     });
     this.provider = await this.createProvider();
   }
@@ -1151,25 +1540,50 @@ function createWalletAdapters({
   appName,
   appLogoUrl,
   modalZIndex,
-  theme
+  theme,
+  telemetry
 }) {
   return [
-    new EmailAdapter({ projectId: walletsConfig?.embedded?.projectId }),
+    new EmailAdapter({ projectId: walletsConfig?.embedded?.projectId, telemetry }),
     new MetaMaskAdapter(),
-    new WalletConnectAdapter({ projectId: walletsConfig?.walletConnect?.projectId, appName }),
-    new CoinbaseWalletAdapter({ appName, appLogoUrl }),
+    new WalletConnectAdapter({
+      projectId: walletsConfig?.walletConnect?.projectId,
+      appName,
+      modalZIndex,
+      theme,
+      telemetry
+    }),
+    new CoinbaseWalletAdapter({ appName, appLogoUrl, telemetry }),
     new PhantomAdapter(),
     new RabbyAdapter(),
-    new BraveAdapter(),
-    new LedgerAdapter({ walletConnectProjectId: walletsConfig?.walletConnect?.projectId }),
-    new AppKitAdapter({ projectId: walletsConfig?.walletConnect?.projectId, appName, modalZIndex, theme })
+    new BraveAdapter()
   ];
 }
 
 // src/AurumCore.ts
-import { WalletId as WalletId9 } from "@aurum-sdk/types";
+import { WalletId as WalletId8 } from "@aurum-sdk/types";
 
 // src/providers/RpcProvider.ts
+var ProviderRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.name = "ProviderRpcError";
+    this.code = code;
+    this.data = data;
+  }
+};
+var ProviderErrorCode = {
+  USER_REJECTED: 4001,
+  // User rejected the request
+  UNAUTHORIZED: 4100,
+  // The requested account/method has not been authorized
+  UNSUPPORTED_METHOD: 4200,
+  // The provider does not support the requested method
+  DISCONNECTED: 4900,
+  // The provider is disconnected from all chains
+  CHAIN_DISCONNECTED: 4901
+  // The provider is not connected to the requested chain
+};
 var RpcProvider = class {
   constructor(handleConnect) {
     this.isConnected = false;
@@ -1191,7 +1605,10 @@ var RpcProvider = class {
           const address = await this.handleConnect();
           return [address];
         } else {
-          throw new Error("No wallet connection available. Please use aurum.connect() instead.");
+          throw new ProviderRpcError(
+            ProviderErrorCode.DISCONNECTED,
+            "No wallet connection available. Please use aurum.connect() instead."
+          );
         }
       // Chain/network information
       case "eth_chainId":
@@ -1200,8 +1617,9 @@ var RpcProvider = class {
         return this.networkVersion;
       // Default case for rest of methods
       default:
-        throw new Error(
-          `Method ${method} requires an active connection to a JSON-RPC provider. Please connect a wallet.`
+        throw new ProviderRpcError(
+          ProviderErrorCode.DISCONNECTED,
+          `Method ${method} requires an active wallet connection. Please connect a wallet first.`
         );
     }
   }
@@ -1237,7 +1655,8 @@ var _AurumCore = class _AurumCore {
       appName: this.brandConfig.appName,
       appLogoUrl: this.brandConfig.logo,
       modalZIndex: this.brandConfig.modalZIndex,
-      theme: this.brandConfig.theme
+      theme: this.brandConfig.theme,
+      telemetry: telemetryEnabled
     });
     this.skeletonProvider = new RpcProvider(() => this.connect());
     this.currentProvider = this.skeletonProvider;
@@ -1275,27 +1694,22 @@ var _AurumCore = class _AurumCore {
     }
     let adapter = null;
     let result;
-    if (walletId === WalletId9.WalletConnect) {
-      if (this.excludedWallets.has(walletId)) {
-        throw new Error(`${walletId} is excluded from wallet options`);
-      }
-      adapter = this.wallets.find((w) => w instanceof AppKitAdapter) || null;
-      if (!adapter) {
-        throw new Error("WalletConnect is not enabled");
-      }
-      result = await adapter.connect();
-    } else if (walletId) {
+    if (walletId) {
       if (this.excludedWallets.has(walletId)) {
         throw new Error(`${walletId} is excluded from wallet options`);
       }
       adapter = this.wallets.find((w) => w.id === walletId) || null;
       if (!adapter) {
-        throw new Error(`${walletId} is not enabled`);
+        throw new Error(`${walletId} is not configured`);
       }
-      if (!adapter.isInstalled()) {
-        throw new Error(`${adapter.name} is not installed`);
+      if (walletId === WalletId8.WalletConnect && adapter.openModal) {
+        result = await adapter.openModal();
+      } else {
+        if (!adapter.isInstalled()) {
+          throw new Error(`${adapter.name} is not installed`);
+        }
+        result = await adapter.connect();
       }
-      result = await adapter.connect();
     } else {
       const displayedWallets = this.wallets.filter((w) => !this.excludedWallets.has(w.id));
       const modalResult = await renderConnectModal({ displayedWallets, brandConfig: this.brandConfig });
@@ -1406,6 +1820,10 @@ var _AurumCore = class _AurumCore {
       font: "font" in newConfig ? newConfig.font ?? defaultTheme.font : this.brandConfig.font,
       walletLayout: "walletLayout" in newConfig ? newConfig.walletLayout ?? defaultTheme.walletLayout : this.brandConfig.walletLayout
     };
+    if ("theme" in newConfig && this.brandConfig.theme) {
+      const wcAdapter = this.wallets.find((w) => w.id === WalletId8.WalletConnect);
+      wcAdapter?.updateTheme(this.brandConfig.theme);
+    }
   }
   updateWalletsConfig(newConfig) {
     if (newConfig.exclude !== void 0) {
@@ -1419,9 +1837,9 @@ var _AurumCore = class _AurumCore {
    */
   async emailAuthStart(email) {
     await this.whenReady();
-    const emailAdapter = this.wallets.find((w) => w.id === WalletId9.Email);
+    const emailAdapter = this.wallets.find((w) => w.id === WalletId8.Email);
     if (!emailAdapter || !emailAdapter.emailAuthStart) {
-      throw new Error("Email wallet is not enabled");
+      throw new Error("Email wallet is not configured");
     }
     const result = await emailAdapter.emailAuthStart(email);
     return { flowId: result.flowId };
@@ -1434,9 +1852,9 @@ var _AurumCore = class _AurumCore {
    */
   async emailAuthVerify(flowId, otp) {
     await this.whenReady();
-    const emailAdapter = this.wallets.find((w) => w.id === WalletId9.Email);
+    const emailAdapter = this.wallets.find((w) => w.id === WalletId8.Email);
     if (!emailAdapter || !emailAdapter.emailAuthVerify) {
-      throw new Error("Email wallet is not enabled");
+      throw new Error("Email wallet is not configured");
     }
     const verifyResult = await emailAdapter.emailAuthVerify(flowId, otp);
     const provider = emailAdapter.getProvider();
@@ -1473,10 +1891,7 @@ var _AurumCore = class _AurumCore {
    */
   async getWalletConnectSession() {
     await this.whenReady();
-    if (this.excludedWallets.has(WalletId9.WalletConnect)) {
-      throw new Error("WalletConnect is excluded from wallet options");
-    }
-    const wcAdapter = this.wallets.find((w) => w instanceof WalletConnectAdapter);
+    const wcAdapter = this.wallets.find((w) => w.id === WalletId8.WalletConnect);
     if (!wcAdapter) {
       throw new Error("WalletConnect is not enabled");
     }
@@ -1496,8 +1911,7 @@ var _AurumCore = class _AurumCore {
         this.userInfo = {
           publicAddress: checksumAdr,
           walletName: wcAdapter.name,
-          walletId: wcAdapter.id,
-          email: void 0
+          walletId: wcAdapter.id
         };
         this.persistConnectionState(wcAdapter, checksumAdr);
         this.setInternalAccountChangeListener(wcAdapter);
@@ -1800,8 +2214,7 @@ var Aurum = class {
    * Opens the wallet connection modal or connects directly to a specific wallet.
    *
    * @param walletId - Optional wallet ID for direct connection (bypasses modal).
-   *                   Cannot be 'email' (use emailAuthStart/emailAuthVerify).
-   *                   For 'walletconnect', opens the WalletConnect modal directly.
+   *                   Cannot be 'email' or 'walletconnect' (use their dedicated methods).
    * @returns The connected wallet address
    * @throws Error if user closes the modal without connecting a wallet
    *
@@ -1813,9 +2226,6 @@ var Aurum = class {
    * // Or connect directly to a specific wallet
    * import { WalletId } from '@aurum-sdk/types';
    * const address = await aurum.connect(WalletId.MetaMask);
-   *
-   * // Open WalletConnect modal directly
-   * const address = await aurum.connect(WalletId.WalletConnect);
    * ```
    */
   async connect(walletId) {
@@ -1945,7 +2355,7 @@ var Aurum = class {
    *
    * @param email - The email address to send the OTP to
    * @returns Object containing flowId to use with emailAuthVerify
-   * @throws Error if email wallet is not enabled
+   * @throws Error if email wallet is not configured
    *
    * @example
    * ```typescript
@@ -1981,7 +2391,7 @@ var Aurum = class {
    * Use this for building custom QR code UIs instead of using the built-in modal.
    *
    * @returns Object containing the URI and a function to wait for the connection
-   * @throws Error if WalletConnect is not enabled
+   * @throws Error if WalletConnect is not configured
    *
    * @example
    * ```typescript