@aurum-sdk/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2433 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkDHEVW7CRjs = require('./chunk-DHEVW7CR.js');
+
+// src/AurumCore.ts
+var _viem = require('viem');
+
+// src/utils/chainHelpers.ts
+function normalizeChainId(chainId) {
+  if (typeof chainId === "string" && chainId.startsWith("0x")) return chainId;
+  const numericId = typeof chainId === "number" ? chainId : Number(chainId);
+  if (Number.isNaN(numericId)) {
+    throw new Error(`Invalid chainId: ${chainId}`);
+  }
+  return `0x${numericId.toString(16)}`;
+}
+function isChainNotAddedError(error) {
+  return Boolean(
+    _optionalChain([error, 'optionalAccess', _2 => _2.code]) === 4902 || _optionalChain([error, 'optionalAccess', _3 => _3.message, 'optionalAccess', _4 => _4.includes, 'call', _5 => _5("Unrecognized chain ID")]) || _optionalChain([error, 'optionalAccess', _6 => _6.message, 'optionalAccess', _7 => _7.includes, 'call', _8 => _8("Chain ID not supported")])
+  );
+}
+function isChainExistsError(error) {
+  return Boolean(
+    _optionalChain([error, 'optionalAccess', _9 => _9.code]) === 4001 || // User rejected
+    _optionalChain([error, 'optionalAccess', _10 => _10.code]) === -32e3 || // Chain already pending/exists
+    _optionalChain([error, 'optionalAccess', _11 => _11.message, 'optionalAccess', _12 => _12.includes, 'call', _13 => _13("already exists")]) || _optionalChain([error, 'optionalAccess', _14 => _14.message, 'optionalAccess', _15 => _15.includes, 'call', _16 => _16("already pending")])
+  );
+}
+
+// src/components/ConnectModal/ModalShell.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var ModalShell = ({ onClose, brandConfig }) => {
+  const [isOpen, setIsOpen] = _react.useState.call(void 0, true);
+  const { currentPage } = _chunkDHEVW7CRjs.useNavigation.call(void 0, );
+  const handleClose = () => {
+    setIsOpen(false);
+    onClose();
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _chunkDHEVW7CRjs.Modal,
+    {
+      isOpen,
+      closeOnOverlayClick: true,
+      onCloseComplete: handleClose,
+      brandConfig,
+      transitionKey: currentPage,
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkDHEVW7CRjs.ConnectPages, {})
+    }
+  );
+};
+
+// src/utils/createModalContainer.ts
+var _client = require('react-dom/client');
+
+// src/utils/createShadowRoot.ts
+function createShadowRoot(container, brandConfig) {
+  const shadowRoot = container.attachShadow({ mode: "open" });
+  shadowRoot.innerHTML = `
+    <style>${_chunkDHEVW7CRjs.generateCompleteStyles.call(void 0, brandConfig)}</style>
+    <div class="aurum-modal-root"></div>
+  `;
+  return shadowRoot.querySelector(".aurum-modal-root");
+}
+
+// src/utils/createModalContainer.ts
+var activeRoots = /* @__PURE__ */ new Map();
+function createModalContainer(id, brandConfig) {
+  const existingRoot = activeRoots.get(id);
+  if (existingRoot) {
+    existingRoot.unmount();
+    _optionalChain([document, 'access', _17 => _17.getElementById, 'call', _18 => _18(id), 'optionalAccess', _19 => _19.remove, 'call', _20 => _20()]);
+    activeRoots.delete(id);
+  }
+  const container = document.createElement("div");
+  container.id = id;
+  document.body.appendChild(container);
+  const shadowDOMRoot = createShadowRoot(container, brandConfig);
+  const root = _client.createRoot.call(void 0, shadowDOMRoot);
+  activeRoots.set(id, root);
+  const cleanup = () => {
+    root.unmount();
+    container.remove();
+    activeRoots.delete(id);
+  };
+  return { root, cleanup };
+}
+
+// src/components/ConnectModal/renderConnectModal.tsx
+var _types = require('@aurum-sdk/types');
+
+var CONTAINER_ID = "aurum-modal-container";
+function renderConnectModal({
+  displayedWallets,
+  brandConfig
+}) {
+  return new Promise((resolve, reject) => {
+    let sortedWallets = _chunkDHEVW7CRjs.sortWallets.call(void 0, displayedWallets, { filterHidden: false });
+    const hasAppKit = sortedWallets.some((w) => w.id === _types.WalletId.AppKit);
+    if (_chunkDHEVW7CRjs.isMobile.call(void 0, ) && !hasAppKit) {
+      sortedWallets = sortedWallets.filter((w) => w.id !== _types.WalletId.WalletConnect);
+    }
+    const { root, cleanup } = createModalContainer(CONTAINER_ID, brandConfig);
+    const onConnect = (result) => {
+      cleanup();
+      resolve(result);
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("User rejected request"));
+    };
+    root.render(
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkDHEVW7CRjs.ThemeContainer, { theme: brandConfig.theme, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkDHEVW7CRjs.ConnectUIProviders, { onConnect, displayedWallets: sortedWallets, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ModalShell, { onClose, brandConfig }) }) })
+    );
+  });
+}
+
+// src/wallet-adapters/AppKitAdapter.ts
+var _logos = require('@aurum-sdk/logos');
+
+var AppKitAdapter = class {
+  constructor(config) {
+    this.id = _types.WalletId.AppKit;
+    this.name = _types.WalletName.AppKit;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.AppKit, "brand"), () => ( ""));
+    this.hide = true;
+    this.downloadUrl = null;
+    this.wcDeepLinkUrl = null;
+    this.modal = null;
+    this.wagmiAdapter = null;
+    this.provider = null;
+    this.address = null;
+    this.accountsChangedCallback = null;
+    this.unsubscribeFunctions = [];
+    this.initPromise = null;
+    this.config = {
+      projectId: config.projectId,
+      appName: config.appName,
+      modalZIndex: config.modalZIndex,
+      theme: config.theme
+    };
+  }
+  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: mainnet2 }] = await Promise.all([
+      Promise.resolve().then(() => _interopRequireWildcard(require("@reown/appkit"))),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@reown/appkit-adapter-wagmi"))),
+      Promise.resolve().then(() => _interopRequireWildcard(require("@reown/appkit/networks")))
+    ]);
+    const networks = [mainnet2];
+    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
+      }
+    });
+    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);
+  }
+  syncAddressFromWagmi() {
+    if (!_optionalChain([this, 'access', _21 => _21.wagmiAdapter, 'optionalAccess', _22 => _22.wagmiConfig])) return;
+    const { state } = this.wagmiAdapter.wagmiConfig;
+    if (state.current && state.connections) {
+      const connection = state.connections.get(state.current);
+      if (_optionalChain([connection, 'optionalAccess', _23 => _23.accounts, 'optionalAccess', _24 => _24[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 = _optionalChain([providers, 'optionalAccess', _25 => _25["eip155"]]);
+        if (eip155Provider) {
+          this.provider = eip155Provider;
+          return;
+        }
+      }
+      if (_optionalChain([this, 'access', _26 => _26.wagmiAdapter, 'optionalAccess', _27 => _27.wagmiConfig])) {
+        const { state } = this.wagmiAdapter.wagmiConfig;
+        if (state.current && state.connections) {
+          const connection = state.connections.get(state.current);
+          const connector = _optionalChain([connection, 'optionalAccess', _28 => _28.connector]);
+          if (connector && typeof connector.getProvider === "function") {
+            try {
+              const provider = await connector.getProvider();
+              if (provider) {
+                this.provider = provider;
+              }
+            } catch (error) {
+              _chunkDHEVW7CRjs.sentryLogger.warn("Failed to get provider from wagmi connector", { error });
+            }
+          }
+        }
+      }
+    } catch (error) {
+      _chunkDHEVW7CRjs.sentryLogger.warn("Failed to get provider from AppKit", { error });
+    }
+  }
+  isInstalled() {
+    return true;
+  }
+  async connect() {
+    if (!this.config.projectId) {
+      throw _chunkDHEVW7CRjs.createConfigError.call(void 0, "AppKit");
+    }
+    await this.ensureInitialized();
+    if (!this.modal) {
+      _chunkDHEVW7CRjs.sentryLogger.error("AppKit is not available");
+      throw new Error("AppKit is not available");
+    }
+    const existingAddress = this.modal.getAddress();
+    if (this.modal.getIsConnectedState() && existingAddress) {
+      await this.syncProviderFromModal();
+      if (this.provider) {
+        this.address = existingAddress;
+        return {
+          address: existingAddress,
+          provider: this.provider,
+          walletId: this.id
+        };
+      }
+      await this.disconnect();
+    }
+    this.modal.open({ view: "Connect" });
+    return await this.waitForConnection();
+  }
+  waitForConnection(timeout = 6e4) {
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let unsubscribeState = null;
+      let isResolved = false;
+      const cleanup = () => {
+        _optionalChain([unsubscribeState, 'optionalCall', _29 => _29()]);
+      };
+      const checkConnection = async () => {
+        if (isResolved) 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 && accounts.length > 0) {
+              isResolved = true;
+              cleanup();
+              _optionalChain([this, 'access', _30 => _30.modal, 'optionalAccess', _31 => _31.close, 'call', _32 => _32()]);
+              resolve({
+                address: this.address,
+                provider: this.provider,
+                walletId: this.id
+              });
+              return true;
+            }
+            return false;
+          } catch (e) {
+            return false;
+          }
+        }
+        return false;
+      };
+      unsubscribeState = this.modal.subscribeState(async (state) => {
+        if (await checkConnection()) return;
+        if (state.open === false && !this.address && !isResolved) {
+          cleanup();
+          reject(new Error("Connection rejected by user"));
+        }
+      });
+      const pollTimeout = async () => {
+        if (await checkConnection()) return;
+        if (Date.now() - startTime > timeout) {
+          cleanup();
+          reject(new Error("Connection timeout"));
+          return;
+        }
+        setTimeout(pollTimeout, 500);
+      };
+      pollTimeout();
+    });
+  }
+  async tryRestoreConnection() {
+    await this.ensureInitialized();
+    if (!this.modal || !this.wagmiAdapter) return null;
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const wagmiConfig = this.wagmiAdapter.wagmiConfig;
+      if (_optionalChain([wagmiConfig, 'optionalAccess', _33 => _33.state, 'optionalAccess', _34 => _34.current]) && wagmiConfig.state.connections) {
+        const connection = wagmiConfig.state.connections.get(wagmiConfig.state.current);
+        if (_optionalChain([connection, 'optionalAccess', _35 => _35.accounts, 'optionalAccess', _36 => _36[0]])) {
+          this.address = connection.accounts[0];
+          if (this.provider && this.address) {
+            return {
+              address: this.address,
+              provider: this.provider,
+              walletId: this.id
+            };
+          }
+        }
+      }
+      return null;
+    } catch (e2) {
+      return null;
+    }
+  }
+  async disconnect() {
+    if (!this.modal) {
+      this.address = null;
+      this.provider = null;
+      return;
+    }
+    await this.modal.disconnect("eip155");
+    const timeout = Date.now() + 2e3;
+    while (Date.now() < timeout && (this.modal.getIsConnectedState() || this.modal.getAddress())) {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    this.address = null;
+    this.provider = null;
+  }
+  getProvider() {
+    return this.provider;
+  }
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _37 => _37.provider, 'optionalAccess', _38 => _38.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _39 => _39.provider, 'access', _40 => _40.removeListener, 'optionalCall', _41 => _41("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = (accounts) => {
+      this.address = accounts[0] || null;
+      callback(accounts);
+    };
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (_optionalChain([this, 'access', _42 => _42.provider, 'optionalAccess', _43 => _43.removeListener]) && this.accountsChangedCallback) {
+      this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+      this.accountsChangedCallback = null;
+    }
+    this.unsubscribeFunctions.forEach((unsub) => unsub());
+    this.unsubscribeFunctions = [];
+  }
+};
+
+// src/wallet-adapters/RabbyAdapter.ts
+
+
+var RABBY_RDNS = "io.rabby";
+var RabbyAdapter = class {
+  constructor() {
+    this.id = _types.WalletId.Rabby;
+    this.name = _types.WalletName.Rabby;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.Rabby, "brand"), () => ( ""));
+    this.hide = false;
+    this.downloadUrl = "https://rabby.io";
+    this.wcDeepLinkUrl = null;
+    this.provider = null;
+    this.accountsChangedCallback = null;
+    this.providerPromise = null;
+    this.providerPromise = this.discoverProvider();
+  }
+  /**
+   * Uses EIP-6963 to discover the Rabby provider by its RDNS identifier.
+   * Falls back to window.ethereum for legacy detection.
+   */
+  discoverProvider() {
+    if (typeof window === "undefined") return Promise.resolve(null);
+    return new Promise((resolve) => {
+      let resolved = false;
+      const onAnnouncement = (event) => {
+        const { detail } = event;
+        if (detail.info.rdns === RABBY_RDNS) {
+          resolved = true;
+          this.provider = detail.provider;
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          resolve(detail.provider);
+        }
+      };
+      window.addEventListener("eip6963:announceProvider", onAnnouncement);
+      window.dispatchEvent(new Event("eip6963:requestProvider"));
+      setTimeout(() => {
+        if (!resolved) {
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          const legacyProvider = this.detectLegacyProvider();
+          if (legacyProvider) {
+            this.provider = legacyProvider;
+          }
+          resolve(legacyProvider);
+        }
+      }, 100);
+    });
+  }
+  /**
+   * Fallback detection for legacy Rabby installations.
+   * Checks window.ethereum for Rabby-specific flags.
+   */
+  detectLegacyProvider() {
+    const ethereum = window.ethereum;
+    if (_optionalChain([ethereum, 'optionalAccess', _44 => _44.isRabby])) {
+      return ethereum;
+    }
+    return null;
+  }
+  isInstalled() {
+    return Boolean(this.provider);
+  }
+  async connect() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      _chunkDHEVW7CRjs.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]) {
+        _chunkDHEVW7CRjs.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 (e3) {
+      throw new Error("Failed to connect to Rabby");
+    }
+  }
+  async tryRestoreConnection() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      return null;
+    }
+    try {
+      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 (e4) {
+      return null;
+    }
+  }
+  async disconnect() {
+  }
+  getProvider() {
+    return this.provider;
+  }
+  // Called by Aurum when user connects wallet
+  // Passes Aurum.ts --> syncStateFromAccountsChanged() to handle the provider accounts changed event
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _45 => _45.provider, 'optionalAccess', _46 => _46.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _47 => _47.provider, 'access', _48 => _48.removeListener, 'optionalCall', _49 => _49("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _50 => _50.provider, 'optionalAccess', _51 => _51.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+// src/wallet-adapters/BraveAdapter.ts
+
+
+var BRAVE_RDNS = "com.brave.wallet";
+function isBraveBrowser() {
+  if (typeof navigator === "undefined") return false;
+  return navigator.brave !== void 0;
+}
+var BraveAdapter = class {
+  constructor() {
+    this.id = _types.WalletId.Brave;
+    this.name = _types.WalletName.Brave;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.Brave, "brand"), () => ( ""));
+    this.downloadUrl = "https://brave.com/download";
+    this.wcDeepLinkUrl = null;
+    this.provider = null;
+    this.accountsChangedCallback = null;
+    this.providerPromise = null;
+    this.hide = !isBraveBrowser();
+    this.providerPromise = this.discoverProvider();
+  }
+  /**
+   * Uses EIP-6963 to discover the Brave Wallet provider by its RDNS identifier.
+   * Falls back to window.ethereum for legacy detection.
+   */
+  discoverProvider() {
+    if (typeof window === "undefined") return Promise.resolve(null);
+    return new Promise((resolve) => {
+      let resolved = false;
+      const onAnnouncement = (event) => {
+        const { detail } = event;
+        if (detail.info.rdns === BRAVE_RDNS) {
+          resolved = true;
+          this.provider = detail.provider;
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          resolve(detail.provider);
+        }
+      };
+      window.addEventListener("eip6963:announceProvider", onAnnouncement);
+      window.dispatchEvent(new Event("eip6963:requestProvider"));
+      setTimeout(() => {
+        if (!resolved) {
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          const legacyProvider = this.detectLegacyProvider();
+          if (legacyProvider) {
+            this.provider = legacyProvider;
+          }
+          resolve(legacyProvider);
+        }
+      }, 100);
+    });
+  }
+  /**
+   * Fallback detection for legacy Brave Wallet detection.
+   * Checks window.ethereum for Brave-specific flags.
+   */
+  detectLegacyProvider() {
+    const ethereum = window.ethereum;
+    if (_optionalChain([ethereum, 'optionalAccess', _52 => _52.isBraveWallet])) {
+      return ethereum;
+    }
+    return null;
+  }
+  isInstalled() {
+    return Boolean(this.provider);
+  }
+  async connect() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      _chunkDHEVW7CRjs.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]) {
+        _chunkDHEVW7CRjs.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 (e5) {
+      throw new Error("Failed to connect to Brave Wallet");
+    }
+  }
+  async tryRestoreConnection() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      return null;
+    }
+    try {
+      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 (e6) {
+      return null;
+    }
+  }
+  async disconnect() {
+  }
+  getProvider() {
+    return this.provider;
+  }
+  // Called by Aurum when user connects wallet
+  // Passes Aurum.ts --> syncStateFromAccountsChanged() to handle the provider accounts changed event
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _53 => _53.provider, 'optionalAccess', _54 => _54.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _55 => _55.provider, 'access', _56 => _56.removeListener, 'optionalCall', _57 => _57("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _58 => _58.provider, 'optionalAccess', _59 => _59.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+// src/wallet-adapters/LedgerAdapter.ts
+
+
+var _connectkitloader = require('@ledgerhq/connect-kit-loader');
+var _chains = require('viem/chains');
+var LedgerAdapter = class {
+  constructor(config) {
+    this.id = _types.WalletId.Ledger;
+    this.name = _types.WalletName.Ledger;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.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 = _optionalChain([config, 'optionalAccess', _60 => _60.walletConnectProjectId]);
+  }
+  isInstalled() {
+    return true;
+  }
+  async connect() {
+    try {
+      if (!this.walletConnectProjectId) {
+        throw _chunkDHEVW7CRjs.createConfigError.call(void 0, "Ledger");
+      }
+      const { loadConnectKit } = await Promise.resolve().then(() => _interopRequireWildcard(require("@ledgerhq/connect-kit-loader")));
+      const connectKit = await loadConnectKit();
+      connectKit.enableDebugLogs();
+      connectKit.checkSupport({
+        providerType: _connectkitloader.SupportedProviders.Ethereum,
+        chainId: 1,
+        walletConnectVersion: 2,
+        projectId: this.walletConnectProjectId,
+        rpc: { 1: _chains.mainnet.rpcUrls.default.http[0] }
+      });
+      this.provider = await connectKit.getProvider();
+      if (!this.provider) {
+        _chunkDHEVW7CRjs.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]) {
+        _chunkDHEVW7CRjs.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 (e7) {
+      throw new Error("Failed to connect to Ledger");
+    }
+  }
+  async tryRestoreConnection() {
+    try {
+      const { loadConnectKit } = await Promise.resolve().then(() => _interopRequireWildcard(require("@ledgerhq/connect-kit-loader")));
+      const connectKit = await loadConnectKit();
+      connectKit.checkSupport({
+        providerType: _connectkitloader.SupportedProviders.Ethereum,
+        chainId: 1,
+        walletConnectVersion: 2,
+        projectId: this.walletConnectProjectId,
+        rpc: { 1: _chains.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 (e8) {
+      return null;
+    }
+  }
+  async disconnect() {
+    try {
+      const provider = this.provider;
+      if (_optionalChain([provider, 'optionalAccess', _61 => _61.disconnect])) {
+        await provider.disconnect();
+      }
+      this.provider = null;
+    } catch (error) {
+      _chunkDHEVW7CRjs.sentryLogger.warn("Failed to disconnect from Ledger", { error });
+    }
+  }
+  getProvider() {
+    return this.provider;
+  }
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _62 => _62.provider, 'optionalAccess', _63 => _63.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _64 => _64.provider, 'access', _65 => _65.removeListener, 'optionalCall', _66 => _66("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _67 => _67.provider, 'optionalAccess', _68 => _68.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+// src/wallet-adapters/PhantomAdapter.ts
+
+
+var PHANTOM_RDNS = "app.phantom";
+var PhantomAdapter = class {
+  constructor() {
+    this.id = _types.WalletId.Phantom;
+    this.name = _types.WalletName.Phantom;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.Phantom, "brand"), () => ( ""));
+    this.hide = false;
+    this.downloadUrl = "https://phantom.com/download";
+    this.wcDeepLinkUrl = "phantom://wc?uri=";
+    this.provider = null;
+    this.accountsChangedCallback = null;
+    this.providerPromise = null;
+    this.providerPromise = this.discoverProvider();
+  }
+  /**
+   * Uses EIP-6963 to discover the Phantom provider by its RDNS identifier.
+   * Falls back to window.phantom.ethereum for in-app browser support (Phantom Mobile).
+   * This prevents other wallets from hijacking the connection.
+   */
+  discoverProvider() {
+    if (typeof window === "undefined") return Promise.resolve(null);
+    return new Promise((resolve) => {
+      let resolved = false;
+      const onAnnouncement = (event) => {
+        const { detail } = event;
+        if (detail.info.rdns === PHANTOM_RDNS) {
+          resolved = true;
+          this.provider = detail.provider;
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          resolve(detail.provider);
+        }
+      };
+      window.addEventListener("eip6963:announceProvider", onAnnouncement);
+      window.dispatchEvent(new Event("eip6963:requestProvider"));
+      setTimeout(() => {
+        if (!resolved) {
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          const legacyProvider = this.detectLegacyProvider();
+          if (legacyProvider) {
+            this.provider = legacyProvider;
+          }
+          resolve(legacyProvider);
+        }
+      }, 100);
+    });
+  }
+  /**
+   * Fallback detection for in-app browsers (Phantom Mobile) that don't support EIP-6963.
+   * Checks window.phantom.ethereum and window.ethereum for Phantom-specific flags.
+   */
+  detectLegacyProvider() {
+    const phantom = window.phantom;
+    if (_optionalChain([phantom, 'optionalAccess', _69 => _69.ethereum, 'optionalAccess', _70 => _70.isPhantom])) {
+      return phantom.ethereum;
+    }
+    const ethereum = window.ethereum;
+    if (_optionalChain([ethereum, 'optionalAccess', _71 => _71.isPhantom])) {
+      return ethereum;
+    }
+    return null;
+  }
+  isInstalled() {
+    return Boolean(this.provider);
+  }
+  async connect() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      _chunkDHEVW7CRjs.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]) {
+        _chunkDHEVW7CRjs.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 (e9) {
+      throw new Error("Failed to connect to Phantom");
+    }
+  }
+  async tryRestoreConnection() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      return null;
+    }
+    try {
+      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 (e10) {
+      return null;
+    }
+  }
+  async disconnect() {
+  }
+  getProvider() {
+    return this.provider;
+  }
+  // Called by Aurum when user connects wallet
+  // Passes Aurum.ts --> syncStateFromAccountsChanged() to handle the provider accounts changed event
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _72 => _72.provider, 'optionalAccess', _73 => _73.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _74 => _74.provider, 'access', _75 => _75.removeListener, 'optionalCall', _76 => _76("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _77 => _77.provider, 'optionalAccess', _78 => _78.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+// src/wallet-adapters/CoinbaseWalletAdapter.ts
+var _walletsdk = require('@coinbase/wallet-sdk');
+
+
+var CoinbaseWalletAdapter = class {
+  constructor({ appName, appLogoUrl }) {
+    this.id = _types.WalletId.CoinbaseWallet;
+    this.name = _types.WalletName.CoinbaseWallet;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.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 });
+  }
+  detectProvider({ appName, appLogoUrl }) {
+    if (typeof window === "undefined") return null;
+    try {
+      const coinbaseSdk = _walletsdk.createCoinbaseWalletSDK.call(void 0, {
+        appName,
+        appLogoUrl
+      });
+      return coinbaseSdk.getProvider();
+    } catch (error) {
+      _chunkDHEVW7CRjs.sentryLogger.warn("Failed to initialize Coinbase Wallet provider", { error });
+      return null;
+    }
+  }
+  isInstalled() {
+    return Boolean(this.provider);
+  }
+  async connect() {
+    if (!this.isInstalled() || !this.provider) {
+      _chunkDHEVW7CRjs.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]) {
+        _chunkDHEVW7CRjs.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 (e11) {
+      throw new Error("Failed to connect to Coinbase Wallet");
+    }
+  }
+  async tryRestoreConnection() {
+    if (!this.isInstalled() || !this.provider) {
+      return null;
+    }
+    try {
+      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 (e12) {
+      return null;
+    }
+  }
+  async disconnect() {
+    try {
+      if (_optionalChain([this, 'access', _79 => _79.provider, 'optionalAccess', _80 => _80.close])) {
+        await this.provider.close();
+      } else if (_optionalChain([this, 'access', _81 => _81.provider, 'optionalAccess', _82 => _82.disconnect])) {
+        await this.provider.disconnect();
+      }
+    } catch (error) {
+      _chunkDHEVW7CRjs.sentryLogger.warn("Error disconnecting from Coinbase Wallet", { error });
+    } finally {
+      this.clearLocalStorage();
+    }
+  }
+  clearLocalStorage() {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key && (key.startsWith("-walletlink") || key.startsWith("-CBWSDK") || key.startsWith("walletlink:") || key.startsWith("CBWSDK:"))) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((key) => {
+      localStorage.removeItem(key);
+    });
+  }
+  getProvider() {
+    return this.provider;
+  }
+  // Called by Aurum when user connects wallet
+  // Passes Aurum.ts --> syncStateFromAccountsChanged() to handle the provider accounts changed event
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _83 => _83.provider, 'optionalAccess', _84 => _84.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _85 => _85.provider, 'access', _86 => _86.removeListener, 'optionalCall', _87 => _87("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _88 => _88.provider, 'optionalAccess', _89 => _89.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+// src/wallet-adapters/MetaMaskAdapter.ts
+
+
+var METAMASK_RDNS = "io.metamask";
+var MetaMaskAdapter = class {
+  constructor() {
+    this.id = _types.WalletId.MetaMask;
+    this.name = _types.WalletName.MetaMask;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.MetaMask, "brand"), () => ( ""));
+    this.hide = false;
+    this.downloadUrl = "https://metamask.io/download";
+    this.wcDeepLinkUrl = "metamask://wc?uri=";
+    this.provider = null;
+    this.accountsChangedCallback = null;
+    this.providerPromise = null;
+    this.providerPromise = this.discoverProvider();
+  }
+  /**
+   * Uses EIP-6963 to discover the MetaMask provider by its RDNS identifier.
+   * Falls back to window.ethereum for in-app browser support (MetaMask Mobile).
+   * This prevents other wallets (like Rabby) from hijacking the connection.
+   */
+  discoverProvider() {
+    if (typeof window === "undefined") return Promise.resolve(null);
+    return new Promise((resolve) => {
+      let resolved = false;
+      const onAnnouncement = (event) => {
+        const { detail } = event;
+        if (detail.info.rdns === METAMASK_RDNS) {
+          resolved = true;
+          this.provider = detail.provider;
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          resolve(detail.provider);
+        }
+      };
+      window.addEventListener("eip6963:announceProvider", onAnnouncement);
+      window.dispatchEvent(new Event("eip6963:requestProvider"));
+      setTimeout(() => {
+        if (!resolved) {
+          window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+          const legacyProvider = this.detectLegacyProvider();
+          if (legacyProvider) {
+            this.provider = legacyProvider;
+          }
+          resolve(legacyProvider);
+        }
+      }, 100);
+    });
+  }
+  /**
+   * Fallback detection for in-app browsers (MetaMask Mobile) that don't support EIP-6963.
+   * Checks window.ethereum for MetaMask-specific flags.
+   */
+  detectLegacyProvider() {
+    const ethereum = window.ethereum;
+    if (!ethereum) return null;
+    if (_optionalChain([ethereum, 'access', _90 => _90.providers, 'optionalAccess', _91 => _91.length])) {
+      const metaMaskProvider = ethereum.providers.find((p) => p.isMetaMask && !p.isBraveWallet);
+      if (metaMaskProvider) return metaMaskProvider;
+    }
+    if (ethereum.isMetaMask && !ethereum.isBraveWallet) {
+      return ethereum;
+    }
+    return null;
+  }
+  isInstalled() {
+    return Boolean(this.provider);
+  }
+  async connect() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      _chunkDHEVW7CRjs.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]) {
+        _chunkDHEVW7CRjs.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 (e13) {
+      throw new Error("Failed to connect to MetaMask");
+    }
+  }
+  async tryRestoreConnection() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      return null;
+    }
+    try {
+      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 (e14) {
+      return null;
+    }
+  }
+  async disconnect() {
+  }
+  getProvider() {
+    return this.provider;
+  }
+  // Called by Aurum when user connects wallet
+  // Passes Aurum.ts --> syncStateFromAccountsChanged() to handle the provider accounts changed event
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _92 => _92.provider, 'optionalAccess', _93 => _93.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _94 => _94.provider, 'access', _95 => _95.removeListener, 'optionalCall', _96 => _96("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _97 => _97.provider, 'optionalAccess', _98 => _98.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+// src/wallet-adapters/WalletConnectAdapter.ts
+
+
+var WalletConnectAdapter = class {
+  constructor(config) {
+    this.id = _types.WalletId.WalletConnect;
+    this.name = _types.WalletName.WalletConnect;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.WalletConnect, "brand"), () => ( ""));
+    this.hide = false;
+    this.downloadUrl = null;
+    this.wcDeepLinkUrl = null;
+    this.provider = null;
+    this.connectionUri = null;
+    this.accountsChangedCallback = null;
+    this.initPromise = null;
+    this.config = {
+      projectId: config.projectId,
+      appName: config.appName
+    };
+  }
+  async ensureInitialized() {
+    if (this.provider) return;
+    if (!this.initPromise) {
+      this.initPromise = this.initializeProvider();
+    }
+    await this.initPromise;
+  }
+  async initializeProvider() {
+    if (typeof window === "undefined") return;
+    const { EthereumProvider } = await Promise.resolve().then(() => _interopRequireWildcard(require("@walletconnect/ethereum-provider")));
+    this.provider = await EthereumProvider.init({
+      projectId: _nullishCoalesce(this.config.projectId, () => ( "")),
+      optionalChains: [1],
+      showQrModal: false,
+      metadata: {
+        name: this.config.appName,
+        description: this.config.appName,
+        url: window.location.origin,
+        icons: []
+      }
+    });
+    this.provider.on("display_uri", (uri) => {
+      this.connectionUri = uri;
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent("walletconnect:uri", { detail: { uri } }));
+      }
+    });
+    this.provider.on("connect", (session) => {
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent("walletconnect:connect", { detail: { session } }));
+      }
+    });
+    this.provider.on("disconnect", () => {
+      this.connectionUri = null;
+    });
+    this.provider.on("session_delete", () => {
+      if (typeof window !== "undefined") {
+        window.dispatchEvent(new CustomEvent("walletconnect:disconnect"));
+      }
+    });
+  }
+  isInstalled() {
+    return true;
+  }
+  async connect() {
+    if (!this.config.projectId) {
+      throw _chunkDHEVW7CRjs.createConfigError.call(void 0, "WalletConnect");
+    }
+    try {
+      await this.ensureInitialized();
+      if (!this.provider) {
+        _chunkDHEVW7CRjs.sentryLogger.error("connect: WalletConnect is not available");
+        throw new Error("WalletConnect is not available");
+      }
+      const accounts = await this.provider.enable();
+      if (!accounts || accounts.length === 0 || !accounts[0]) {
+        _chunkDHEVW7CRjs.sentryLogger.error("connect: No accounts returned from WalletConnect");
+        throw new Error("No accounts returned from WalletConnect");
+      }
+      return {
+        address: accounts[0],
+        provider: this.provider,
+        walletId: this.id
+      };
+    } catch (e15) {
+      this.connectionUri = null;
+      throw new Error("Failed to connect to WalletConnect");
+    }
+  }
+  getConnectionUri() {
+    return this.connectionUri;
+  }
+  /**
+   * 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.provider) {
+      _chunkDHEVW7CRjs.sentryLogger.error("startSession: WalletConnect is not available");
+      throw new Error("WalletConnect is not available");
+    }
+    this.connectionUri = null;
+    const uriPromise = new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error("Timeout waiting for WalletConnect URI"));
+      }, timeout);
+      this.provider.once("display_uri", (uri2) => {
+        clearTimeout(timeoutId);
+        this.connectionUri = uri2;
+        resolve(uri2);
+      });
+    });
+    const connectionPromise = (async () => {
+      const accounts = await this.provider.enable();
+      if (!accounts || accounts.length === 0 || !accounts[0]) {
+        _chunkDHEVW7CRjs.sentryLogger.error("startSession: No accounts returned from WalletConnect");
+        throw new Error("No accounts returned from WalletConnect");
+      }
+      return {
+        address: accounts[0],
+        provider: this.provider,
+        walletId: this.id
+      };
+    })();
+    const uri = await uriPromise;
+    return {
+      uri,
+      waitForConnection: async () => {
+        try {
+          return await connectionPromise;
+        } catch (e16) {
+          this.connectionUri = null;
+          throw new Error("Failed to connect via WalletConnect");
+        }
+      }
+    };
+  }
+  async tryRestoreConnection() {
+    try {
+      await this.ensureInitialized();
+      if (!this.provider) {
+        return null;
+      }
+      const accounts = this.provider.accounts;
+      if (!accounts || accounts.length === 0 || !accounts[0]) {
+        return null;
+      }
+      return {
+        address: accounts[0],
+        provider: this.provider,
+        walletId: this.id
+      };
+    } catch (e17) {
+      return null;
+    }
+  }
+  async disconnect() {
+    try {
+      if (this.provider) {
+        await this.provider.disconnect();
+      }
+    } finally {
+      this.connectionUri = null;
+      this.provider = null;
+      this.initPromise = null;
+    }
+  }
+  getProvider() {
+    return this.provider;
+  }
+  // Called by Aurum when user connects wallet
+  // Passes Aurum.ts --> syncStateFromAccountsChanged() to handle the provider accounts changed event
+  onAccountsChanged(callback) {
+    if (!_optionalChain([this, 'access', _99 => _99.provider, 'optionalAccess', _100 => _100.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _101 => _101.provider, 'access', _102 => _102.removeListener, 'optionalCall', _103 => _103("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _104 => _104.provider, 'optionalAccess', _105 => _105.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+// src/wallet-adapters/EmailAdapter.ts
+
+
+var _EmailAdapter = class _EmailAdapter {
+  constructor(config) {
+    this.id = _types.WalletId.Email;
+    this.name = _types.WalletName.Email;
+    this.icon = _nullishCoalesce(_logos.getLogoDataUri.call(void 0, _types.WalletId.Email, "brand"), () => ( ""));
+    this.hide = true;
+    this.downloadUrl = null;
+    this.wcDeepLinkUrl = null;
+    this.provider = null;
+    this.initPromise = null;
+    this.publicClientCache = /* @__PURE__ */ new Map();
+    this.projectId = _optionalChain([config, 'optionalAccess', _106 => _106.projectId]) || "";
+  }
+  async ensureInitialized() {
+    if (this.provider) return;
+    if (!this.initPromise) {
+      this.initPromise = this.initializeProvider();
+    }
+    await this.initPromise;
+  }
+  isInstalled() {
+    return true;
+  }
+  async emailAuthStart(email) {
+    if (!this.projectId) {
+      throw _chunkDHEVW7CRjs.createConfigError.call(void 0, "Email");
+    }
+    await this.ensureInitialized();
+    if (!this.provider) {
+      _chunkDHEVW7CRjs.sentryLogger.error("Email is not available");
+      throw new Error("Email is not available");
+    }
+    try {
+      const { signInWithEmail } = await Promise.resolve().then(() => _interopRequireWildcard(require("@coinbase/cdp-core")));
+      const authResult = await signInWithEmail({ email });
+      return authResult;
+    } catch (error) {
+      _chunkDHEVW7CRjs.sentryLogger.error("Failed to start email authentication", { error });
+      throw error;
+    }
+  }
+  async emailAuthVerify(flowId, otp) {
+    if (!flowId || !otp) {
+      throw new Error("flowId and otp are required");
+    }
+    await this.ensureInitialized();
+    if (!this.provider) {
+      _chunkDHEVW7CRjs.sentryLogger.error("Email provider not initialized");
+      throw new Error("Email provider not initialized");
+    }
+    const { verifyEmailOTP } = await Promise.resolve().then(() => _interopRequireWildcard(require("@coinbase/cdp-core")));
+    return verifyEmailOTP({ flowId, otp });
+  }
+  async connect() {
+    _chunkDHEVW7CRjs.sentryLogger.error("EmailAdapter.connect() is not implemented");
+    throw new Error("EmailAdapter.connect() is not implemented");
+  }
+  async tryRestoreConnection() {
+    await this.ensureInitialized();
+    if (!this.provider) {
+      return null;
+    }
+    try {
+      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 (e18) {
+      return null;
+    }
+  }
+  async disconnect() {
+    try {
+      await this.ensureInitialized();
+      const { signOut } = await Promise.resolve().then(() => _interopRequireWildcard(require("@coinbase/cdp-core")));
+      await signOut();
+    } catch (e19) {
+    }
+  }
+  getProvider() {
+    return this.provider;
+  }
+  static async initializeChainData() {
+    if (this.chainIdMap !== null) return;
+    const [allChains, { http }] = await Promise.all([Promise.resolve().then(() => _interopRequireWildcard(require("viem/chains"))), Promise.resolve().then(() => _interopRequireWildcard(require("viem")))]);
+    const chains = Object.values(allChains).filter(
+      (chain) => typeof chain === "object" && chain !== null && "id" in chain
+    );
+    this.chainIdMap = new Map(chains.map((chain) => [chain.id, chain]));
+    this.viemChains = chains;
+    this.viemTransports = chains.reduce(
+      (acc, chain) => {
+        acc[chain.id] = http();
+        return acc;
+      },
+      {}
+    );
+  }
+  async getPublicClientForChain(chainId) {
+    if (this.publicClientCache.has(chainId)) {
+      return this.publicClientCache.get(chainId);
+    }
+    await _EmailAdapter.initializeChainData();
+    const viemChain = _EmailAdapter.chainIdMap.get(chainId);
+    if (!viemChain) {
+      throw new Error(`Chain ${chainId} not supported`);
+    }
+    const { createPublicClient, http } = await Promise.resolve().then(() => _interopRequireWildcard(require("viem")));
+    const publicClient = createPublicClient({
+      chain: viemChain,
+      transport: http()
+    });
+    this.publicClientCache.set(chainId, publicClient);
+    return publicClient;
+  }
+  /**
+   * Initializes CDP and creates the provider.
+   * Called by ensureInitialized() - deduplication handled via initPromise.
+   */
+  async initializeProvider() {
+    const { initialize } = await Promise.resolve().then(() => _interopRequireWildcard(require("@coinbase/cdp-core")));
+    await initialize({
+      projectId: this.projectId,
+      ethereum: {
+        createOnLogin: "eoa"
+      }
+    });
+    this.provider = await this.createProvider();
+  }
+  /**
+   * Special case:
+   * Coinbase default provider does not support generic read methods like eth_getBalance.
+   * Wraps the provider to send unsupported methods to a public RPC endpoint.
+   */
+  async createProvider() {
+    try {
+      await _EmailAdapter.initializeChainData();
+      const { createCDPEmbeddedWallet } = await Promise.resolve().then(() => _interopRequireWildcard(require("@coinbase/cdp-core")));
+      const wallet = createCDPEmbeddedWallet({
+        chains: _EmailAdapter.viemChains,
+        transports: _EmailAdapter.viemTransports
+      });
+      const base = wallet.provider;
+      const getPublicClient = this.getPublicClientForChain.bind(this);
+      const wrapped = {
+        ...base,
+        async request(args) {
+          try {
+            return await base.request(args);
+          } catch (err) {
+            const msg = String(_optionalChain([err, 'optionalAccess', _107 => _107.message]) || "");
+            const isUnsupported = msg.includes("not supported") || msg.includes("Unsupported") || _optionalChain([err, 'optionalAccess', _108 => _108.code]) === -32601;
+            if (isUnsupported) {
+              let chainId;
+              try {
+                const chainIdHex = await base.request({ method: "eth_chainId", params: [] });
+                chainId = parseInt(chainIdHex, 16);
+              } catch (e20) {
+                _chunkDHEVW7CRjs.sentryLogger.error("Failed to get chainId for fallback request");
+                throw new Error("Failed to get chainId for fallback request");
+              }
+              const publicClient = await getPublicClient(chainId);
+              return await publicClient.transport.request({
+                method: args.method,
+                params: Array.isArray(args.params) ? args.params : args.params ? [args.params] : void 0
+              });
+            }
+            throw err;
+          }
+        }
+      };
+      return wrapped;
+    } catch (error) {
+      _chunkDHEVW7CRjs.sentryLogger.error("Failed to initialize Email provider", { error });
+      return null;
+    }
+  }
+  // Email wallets don't support account switching - user must re-authenticate to change accounts
+  onAccountsChanged() {
+  }
+  removeListeners() {
+  }
+};
+// Static variables - computed once across all instances
+_EmailAdapter.chainIdMap = null;
+_EmailAdapter.viemChains = null;
+_EmailAdapter.viemTransports = null;
+var EmailAdapter = _EmailAdapter;
+
+// src/utils/createWalletAdapters.ts
+function createWalletAdapters({
+  walletsConfig,
+  appName,
+  appLogoUrl,
+  modalZIndex,
+  theme
+}) {
+  return [
+    new EmailAdapter({ projectId: _optionalChain([walletsConfig, 'optionalAccess', _109 => _109.email, 'optionalAccess', _110 => _110.projectId]) }),
+    new MetaMaskAdapter(),
+    new WalletConnectAdapter({ projectId: _optionalChain([walletsConfig, 'optionalAccess', _111 => _111.walletConnect, 'optionalAccess', _112 => _112.projectId]), appName }),
+    new CoinbaseWalletAdapter({ appName, appLogoUrl }),
+    new PhantomAdapter(),
+    new RabbyAdapter(),
+    new BraveAdapter(),
+    new LedgerAdapter({ walletConnectProjectId: _optionalChain([walletsConfig, 'optionalAccess', _113 => _113.walletConnect, 'optionalAccess', _114 => _114.projectId]) }),
+    new AppKitAdapter({ projectId: _optionalChain([walletsConfig, 'optionalAccess', _115 => _115.walletConnect, 'optionalAccess', _116 => _116.projectId]), appName, modalZIndex, theme })
+  ];
+}
+
+// src/AurumCore.ts
+
+
+// src/providers/RpcProvider.ts
+var RpcProvider = class {
+  constructor(handleConnect) {
+    this.isConnected = false;
+    this.chainId = "0x1";
+    this.networkVersion = "1";
+    this.selectedAddress = null;
+    this.handleConnect = handleConnect;
+  }
+  async request(args) {
+    const { method } = args;
+    switch (method) {
+      // Account methods - return empty when not connected
+      case "eth_accounts":
+        return [];
+      // Trigger connection flow
+      case "enable":
+      case "eth_requestAccounts":
+        if (this.handleConnect) {
+          const address = await this.handleConnect();
+          return [address];
+        } else {
+          throw new Error("No wallet connection available. Please use aurum.connect() instead.");
+        }
+      // Chain/network information
+      case "eth_chainId":
+        return this.chainId;
+      case "net_version":
+        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.`
+        );
+    }
+  }
+  // No-op: disconnected provider doesn't emit events
+  on() {
+  }
+  // No-op: disconnected provider doesn't manage listeners
+  removeListener() {
+  }
+  // No listeners to notify in disconnected state
+  emit() {
+    return false;
+  }
+};
+
+// src/AurumCore.ts
+var _AurumCore = class _AurumCore {
+  constructor(config) {
+    // `true` once we have restored the connection state
+    this.ready = false;
+    this.userInfo = void 0;
+    this.connectedWalletAdapter = null;
+    this.eventListeners = /* @__PURE__ */ new Map();
+    if (_AurumCore.instance) {
+      return _AurumCore.instance;
+    }
+    const telemetryEnabled = config.telemetry !== false;
+    _chunkDHEVW7CRjs.initSentry.call(void 0, telemetryEnabled);
+    this.brandConfig = this.resolveBrandConfig(config);
+    this.excludedWallets = new Set(_nullishCoalesce(_optionalChain([config, 'access', _117 => _117.wallets, 'optionalAccess', _118 => _118.exclude]), () => ( [])));
+    this.wallets = createWalletAdapters({
+      walletsConfig: config.wallets,
+      appName: this.brandConfig.appName,
+      appLogoUrl: this.brandConfig.logo,
+      modalZIndex: this.brandConfig.modalZIndex,
+      theme: this.brandConfig.theme
+    });
+    this.skeletonProvider = new RpcProvider(() => this.connect());
+    this.currentProvider = this.skeletonProvider;
+    this.rpcProvider = this.createProviderProxy();
+    this.readyPromise = this.tryRestoreConnection();
+    _AurumCore.instance = this;
+  }
+  async whenReady() {
+    try {
+      await this.readyPromise;
+    } catch (e21) {
+      this.resetConnectionState();
+      this.ready = true;
+    }
+  }
+  get resolvedBrandConfig() {
+    return this.brandConfig;
+  }
+  get walletAdapters() {
+    return this.wallets;
+  }
+  get excludedWalletIds() {
+    return this.excludedWallets;
+  }
+  async connect(walletId) {
+    await this.whenReady();
+    if (walletId === "email") {
+      throw new Error("Use emailAuthStart() and emailAuthVerify() for email wallet connections");
+    }
+    if (walletId === "walletconnect") {
+      throw new Error("Use getWalletConnectSession() for WalletConnect connections");
+    }
+    if (_optionalChain([this, 'access', _119 => _119.userInfo, 'optionalAccess', _120 => _120.publicAddress]) && _optionalChain([this, 'access', _121 => _121.connectedWalletAdapter, 'optionalAccess', _122 => _122.getProvider, 'call', _123 => _123()])) {
+      if (!walletId || this.userInfo.walletId === walletId) {
+        return this.userInfo.publicAddress;
+      }
+      await this.disconnect();
+    }
+    let adapter = null;
+    let result;
+    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 configured`);
+      }
+      if (!adapter.isInstalled()) {
+        throw new Error(`${adapter.name} is not installed`);
+      }
+      result = await adapter.connect();
+    } else {
+      const displayedWallets = this.wallets.filter((w) => !this.excludedWallets.has(w.id));
+      const modalResult = await renderConnectModal({ displayedWallets, brandConfig: this.brandConfig });
+      if (!modalResult) {
+        _chunkDHEVW7CRjs.sentryLogger.error("Missing modal result");
+        throw new Error("Missing modal result");
+      }
+      adapter = this.wallets.find((w) => w.id === modalResult.walletId) || null;
+      if (!adapter) {
+        _chunkDHEVW7CRjs.sentryLogger.error(`Selected wallet adapter not found: ${modalResult.walletId}`);
+        throw new Error("Selected wallet adapter not found");
+      }
+      result = modalResult;
+    }
+    const provider = _nullishCoalesce(result.provider, () => ( adapter.getProvider()));
+    if (!provider) {
+      _chunkDHEVW7CRjs.sentryLogger.error(`Error fetching provider on login: ${adapter.id}`);
+      throw new Error("Error fetching provider. Please try again.");
+    }
+    const checksumAdr = _viem.checksumAddress.call(void 0, result.address);
+    this.connectedWalletAdapter = adapter;
+    this.updateProvider(provider);
+    this.userInfo = {
+      publicAddress: checksumAdr,
+      walletName: adapter.name,
+      walletId: adapter.id,
+      email: result.email
+    };
+    this.persistConnectionState(adapter, checksumAdr, result.email);
+    this.setInternalAccountChangeListener(adapter);
+    const chainId = await provider.request({ method: "eth_chainId" });
+    this.emitConnect(chainId);
+    this.emitAccountsChanged([checksumAdr]);
+    _chunkDHEVW7CRjs.sentryLogger.info(`Wallet connected: ${adapter.id} (${walletId ? "headless" : "modal"})`);
+    return checksumAdr;
+  }
+  async disconnect() {
+    await this.whenReady();
+    if (this.connectedWalletAdapter) {
+      this.connectedWalletAdapter.removeListeners();
+      await this.connectedWalletAdapter.disconnect();
+    }
+    this.resetConnectionState();
+    this.emitDisconnect();
+    this.emitAccountsChanged([]);
+  }
+  async getUserInfo() {
+    await this.whenReady();
+    return this.userInfo;
+  }
+  async isConnected() {
+    await this.whenReady();
+    return Boolean(
+      _optionalChain([this, 'access', _124 => _124.userInfo, 'optionalAccess', _125 => _125.publicAddress]) && _optionalChain([this, 'access', _126 => _126.userInfo, 'optionalAccess', _127 => _127.walletName]) && _optionalChain([this, 'access', _128 => _128.connectedWalletAdapter, 'optionalAccess', _129 => _129.getProvider, 'call', _130 => _130()])
+    );
+  }
+  async handleWidgetConnection(result) {
+    await this.whenReady();
+    const adapter = this.wallets.find((w) => w.id === result.walletId) || null;
+    if (!adapter) throw new Error("Selected wallet adapter not found");
+    const provider = _nullishCoalesce(result.provider, () => ( adapter.getProvider()));
+    if (!provider) {
+      _chunkDHEVW7CRjs.sentryLogger.error(`Error fetching provider on widget login: ${_optionalChain([result, 'optionalAccess', _131 => _131.walletId])}`);
+      throw new Error("Error fetching provider. Please try again.");
+    }
+    const checksumAdr = _viem.checksumAddress.call(void 0, result.address);
+    this.connectedWalletAdapter = adapter;
+    this.updateProvider(provider);
+    this.userInfo = {
+      publicAddress: checksumAdr,
+      walletName: adapter.name,
+      walletId: adapter.id,
+      email: result.email
+    };
+    this.persistConnectionState(adapter, checksumAdr, result.email);
+    this.setInternalAccountChangeListener(adapter);
+    const chainId = await provider.request({ method: "eth_chainId" });
+    this.emitConnect(chainId);
+    this.emitAccountsChanged([checksumAdr]);
+    _chunkDHEVW7CRjs.sentryLogger.info(`Wallet connected: ${adapter.id} (widget)`);
+  }
+  async getChainId() {
+    await this.whenReady();
+    const chainId = await this.rpcProvider.request({ method: "eth_chainId" });
+    return Number(chainId);
+  }
+  async switchChain(chainId, chain) {
+    await this.whenReady();
+    const hexChainId = normalizeChainId(chainId);
+    try {
+      await this.attemptSwitchChain(hexChainId);
+    } catch (switchError) {
+      if (!isChainNotAddedError(switchError) || !chain) throw switchError;
+      await this.handleMissingChain(hexChainId, chain);
+    }
+  }
+  updateBrandConfig(newConfig) {
+    const defaultTheme = _chunkDHEVW7CRjs.getDefaultThemeConfig.call(void 0, _nullishCoalesce(newConfig.theme, () => ( this.brandConfig.theme)));
+    this.brandConfig = {
+      logo: "logo" in newConfig ? _nullishCoalesce(newConfig.logo, () => ( defaultTheme.logo)) : this.brandConfig.logo,
+      theme: "theme" in newConfig ? _nullishCoalesce(newConfig.theme, () => ( defaultTheme.theme)) : this.brandConfig.theme,
+      primaryColor: "primaryColor" in newConfig ? _nullishCoalesce(newConfig.primaryColor, () => ( defaultTheme.primaryColor)) : this.brandConfig.primaryColor,
+      borderRadius: "borderRadius" in newConfig ? _nullishCoalesce(newConfig.borderRadius, () => ( defaultTheme.borderRadius)) : this.brandConfig.borderRadius,
+      modalZIndex: "modalZIndex" in newConfig ? typeof newConfig.modalZIndex === "number" ? newConfig.modalZIndex : defaultTheme.modalZIndex : this.brandConfig.modalZIndex,
+      appName: "appName" in newConfig ? _nullishCoalesce(newConfig.appName, () => ( defaultTheme.appName)) : this.brandConfig.appName,
+      hideFooter: "hideFooter" in newConfig ? _nullishCoalesce(newConfig.hideFooter, () => ( defaultTheme.hideFooter)) : this.brandConfig.hideFooter,
+      font: "font" in newConfig ? _nullishCoalesce(newConfig.font, () => ( defaultTheme.font)) : this.brandConfig.font,
+      walletLayout: "walletLayout" in newConfig ? _nullishCoalesce(newConfig.walletLayout, () => ( defaultTheme.walletLayout)) : this.brandConfig.walletLayout
+    };
+  }
+  updateWalletsConfig(newConfig) {
+    if (newConfig.exclude !== void 0) {
+      this.excludedWallets = new Set(_nullishCoalesce(newConfig.exclude, () => ( [])));
+    }
+  }
+  /* HEADLESS / WHITELABEL API */
+  /**
+   * Starts the email authentication flow by sending an OTP to the provided email.
+   * @returns flowId to use with emailAuthVerify
+   */
+  async emailAuthStart(email) {
+    await this.whenReady();
+    const emailAdapter = this.wallets.find((w) => w.id === _types.WalletId.Email);
+    if (!emailAdapter || !emailAdapter.emailAuthStart) {
+      throw new Error("Email wallet is not configured");
+    }
+    const result = await emailAdapter.emailAuthStart(email);
+    return { flowId: result.flowId };
+  }
+  /**
+   * Verifies the email OTP and completes the connection.
+   * @param flowId - The flowId returned from emailAuthStart
+   * @param otp - The OTP code the user received via email
+   * @returns The connected wallet address and email
+   */
+  async emailAuthVerify(flowId, otp) {
+    await this.whenReady();
+    const emailAdapter = this.wallets.find((w) => w.id === _types.WalletId.Email);
+    if (!emailAdapter || !emailAdapter.emailAuthVerify) {
+      throw new Error("Email wallet is not configured");
+    }
+    const verifyResult = await emailAdapter.emailAuthVerify(flowId, otp);
+    const provider = emailAdapter.getProvider();
+    if (!provider) {
+      _chunkDHEVW7CRjs.sentryLogger.error("Failed to get provider after email verification");
+      throw new Error("Failed to get provider after email verification");
+    }
+    const address = _optionalChain([verifyResult, 'access', _132 => _132.user, 'optionalAccess', _133 => _133.evmAccounts, 'optionalAccess', _134 => _134[0]]);
+    const email = _optionalChain([verifyResult, 'access', _135 => _135.user, 'optionalAccess', _136 => _136.authenticationMethods, 'optionalAccess', _137 => _137.email, 'optionalAccess', _138 => _138.email]);
+    if (!address || !email) {
+      _chunkDHEVW7CRjs.sentryLogger.error("Address or email not found after email verification");
+      throw new Error("Address or email not found after email verification");
+    }
+    const checksumAdr = _viem.checksumAddress.call(void 0, address);
+    this.connectedWalletAdapter = emailAdapter;
+    this.updateProvider(provider);
+    this.userInfo = {
+      publicAddress: checksumAdr,
+      walletName: emailAdapter.name,
+      walletId: emailAdapter.id,
+      email
+    };
+    this.persistConnectionState(emailAdapter, checksumAdr, email);
+    this.setInternalAccountChangeListener(emailAdapter);
+    const chainId = await provider.request({ method: "eth_chainId" });
+    this.emitConnect(chainId);
+    this.emitAccountsChanged([checksumAdr]);
+    _chunkDHEVW7CRjs.sentryLogger.info(`Wallet connected: ${emailAdapter.id} (headless)`);
+    return { address: checksumAdr, email: _nullishCoalesce(email, () => ( "")), isNewUser: _nullishCoalesce(verifyResult.isNewUser, () => ( false)) };
+  }
+  /**
+   * Initiates a WalletConnect session and returns the URI for displaying a custom QR code.
+   * @returns URI string and a promise that resolves when the user connects
+   */
+  async getWalletConnectSession() {
+    await this.whenReady();
+    const wcAdapter = this.wallets.find((w) => w.id === _types.WalletId.WalletConnect);
+    if (!wcAdapter) {
+      throw new Error("WalletConnect is not enabled");
+    }
+    const session = await wcAdapter.startSession();
+    return {
+      uri: session.uri,
+      waitForConnection: async () => {
+        const result = await session.waitForConnection();
+        const provider = _nullishCoalesce(result.provider, () => ( wcAdapter.getProvider()));
+        if (!provider) {
+          _chunkDHEVW7CRjs.sentryLogger.error("Failed to get provider after WalletConnect connection");
+          throw new Error("Failed to get provider after WalletConnect connection");
+        }
+        const checksumAdr = _viem.checksumAddress.call(void 0, result.address);
+        this.connectedWalletAdapter = wcAdapter;
+        this.updateProvider(provider);
+        this.userInfo = {
+          publicAddress: checksumAdr,
+          walletName: wcAdapter.name,
+          walletId: wcAdapter.id
+        };
+        this.persistConnectionState(wcAdapter, checksumAdr);
+        this.setInternalAccountChangeListener(wcAdapter);
+        const chainId = await provider.request({ method: "eth_chainId" });
+        this.emitConnect(chainId);
+        this.emitAccountsChanged([checksumAdr]);
+        _chunkDHEVW7CRjs.sentryLogger.info(`Wallet connected: ${wcAdapter.id} (headless)`);
+        return checksumAdr;
+      }
+    };
+  }
+  /* PROVIDER METHODS */
+  createProviderProxy() {
+    const handler = {
+      get: (_, prop) => {
+        if (prop === "on") {
+          return (event, callback) => {
+            if (!this.eventListeners.has(event)) {
+              this.eventListeners.set(event, /* @__PURE__ */ new Set());
+            }
+            this.eventListeners.get(event).add(callback);
+            if (!_AurumCore.MANAGED_EVENTS.includes(event)) {
+              _optionalChain([this, 'access', _139 => _139.currentProvider, 'access', _140 => _140.on, 'optionalCall', _141 => _141(event, callback)]);
+            }
+          };
+        }
+        if (prop === "removeListener") {
+          return (event, callback) => {
+            _optionalChain([this, 'access', _142 => _142.eventListeners, 'access', _143 => _143.get, 'call', _144 => _144(event), 'optionalAccess', _145 => _145.delete, 'call', _146 => _146(callback)]);
+            if (!_AurumCore.MANAGED_EVENTS.includes(event)) {
+              _optionalChain([this, 'access', _147 => _147.currentProvider, 'access', _148 => _148.removeListener, 'optionalCall', _149 => _149(event, callback)]);
+            }
+          };
+        }
+        const provider = this.currentProvider;
+        const value = provider[prop];
+        if (typeof value === "function") {
+          return (...args) => {
+            const currentValue = this.currentProvider[prop];
+            if (typeof currentValue === "function") {
+              return currentValue.apply(this.currentProvider, args);
+            }
+            return currentValue;
+          };
+        }
+        return value;
+      }
+    };
+    return new Proxy({}, handler);
+  }
+  updateProvider(newProvider) {
+    this.currentProvider = newProvider;
+    this.eventListeners.forEach((callbacks, event) => {
+      if (!_AurumCore.MANAGED_EVENTS.includes(event)) {
+        callbacks.forEach((callback) => {
+          _optionalChain([newProvider, 'access', _150 => _150.on, 'optionalCall', _151 => _151(event, callback)]);
+        });
+      }
+    });
+  }
+  /* BRAND & THEME METHODS */
+  resolveBrandConfig(config) {
+    const { brand = {} } = config || {};
+    const themeConfig = _chunkDHEVW7CRjs.getDefaultThemeConfig.call(void 0, brand.theme || _chunkDHEVW7CRjs.DEFAULT_THEME);
+    return {
+      logo: _nullishCoalesce(brand.logo, () => ( themeConfig.logo)),
+      theme: _nullishCoalesce(brand.theme, () => ( themeConfig.theme)),
+      primaryColor: _nullishCoalesce(brand.primaryColor, () => ( themeConfig.primaryColor)),
+      borderRadius: _nullishCoalesce(brand.borderRadius, () => ( themeConfig.borderRadius)),
+      modalZIndex: typeof brand.modalZIndex === "number" ? brand.modalZIndex : themeConfig.modalZIndex,
+      appName: _nullishCoalesce(brand.appName, () => ( themeConfig.appName)),
+      hideFooter: _nullishCoalesce(brand.hideFooter, () => ( themeConfig.hideFooter)),
+      font: _nullishCoalesce(brand.font, () => ( themeConfig.font)),
+      walletLayout: _nullishCoalesce(brand.walletLayout, () => ( themeConfig.walletLayout))
+    };
+  }
+  async tryRestoreConnection() {
+    try {
+      await _chunkDHEVW7CRjs.waitForStoreHydration.call(void 0, );
+      const store = _chunkDHEVW7CRjs.useAurumStore.getState();
+      if (!store.isConnected || !store.walletId || !store.address || !store.walletName) {
+        return;
+      }
+      const persistedAdapter = this.wallets.find((w) => w.id === store.walletId) || null;
+      if (!persistedAdapter || !persistedAdapter.isInstalled()) {
+        store.clearConnection();
+        return;
+      }
+      const connectionResult = await persistedAdapter.tryRestoreConnection();
+      if (!connectionResult || connectionResult.address.toLowerCase() !== store.address.toLowerCase()) {
+        store.clearConnection();
+        return;
+      }
+      this.connectedWalletAdapter = persistedAdapter;
+      this.updateProvider(connectionResult.provider);
+      this.userInfo = {
+        publicAddress: _viem.checksumAddress.call(void 0, connectionResult.address),
+        walletName: store.walletName,
+        walletId: persistedAdapter.id,
+        email: _nullishCoalesce(store.email, () => ( void 0))
+      };
+      this.setInternalAccountChangeListener(persistedAdapter);
+    } catch (e22) {
+      this.resetConnectionState();
+    } finally {
+      this.ready = true;
+    }
+  }
+  persistConnectionState(adapter, address, email) {
+    _chunkDHEVW7CRjs.useAurumStore.getState().setConnection(adapter.id, _viem.checksumAddress.call(void 0, address), adapter.name, email);
+  }
+  /* INTERNAL LISTENER METHODS */
+  setInternalAccountChangeListener(adapter) {
+    adapter.onAccountsChanged(async (accounts) => {
+      if (accounts.length === 0) {
+        await this.disconnect();
+        return;
+      }
+      this.syncStateFromAccountsChanged(accounts);
+    });
+  }
+  async syncStateFromAccountsChanged(accounts) {
+    if (!accounts.length || !accounts[0]) return;
+    const prevAccount = _optionalChain([this, 'access', _152 => _152.userInfo, 'optionalAccess', _153 => _153.publicAddress]);
+    const newAccount = _viem.checksumAddress.call(void 0, accounts[0]);
+    if (newAccount !== prevAccount) {
+      this.userInfo = {
+        publicAddress: newAccount,
+        walletName: _optionalChain([this, 'access', _154 => _154.userInfo, 'optionalAccess', _155 => _155.walletName]),
+        walletId: _optionalChain([this, 'access', _156 => _156.userInfo, 'optionalAccess', _157 => _157.walletId]),
+        email: _optionalChain([this, 'access', _158 => _158.userInfo, 'optionalAccess', _159 => _159.email])
+      };
+      if (this.connectedWalletAdapter) {
+        this.persistConnectionState(this.connectedWalletAdapter, newAccount, this.userInfo.email);
+      }
+      this.emitAccountsChanged([newAccount]);
+    }
+  }
+  /**
+   * Emit accountsChanged to listeners registered via rpcProvider.on('accountsChanged', cb)
+   * This is the single source of truth - we don't forward to underlying providers to prevent duplicates
+   */
+  emitAccountsChanged(accounts) {
+    const listeners = this.eventListeners.get("accountsChanged");
+    if (listeners) {
+      listeners.forEach((callback) => callback(accounts));
+    }
+  }
+  /**
+   * Emit connect event per EIP-1193 when provider becomes connected
+   * @param chainId - The chain ID in hex format (e.g., "0x1")
+   */
+  emitConnect(chainId) {
+    const listeners = this.eventListeners.get("connect");
+    if (listeners) {
+      listeners.forEach((callback) => callback({ chainId }));
+    }
+  }
+  /**
+   * Emit disconnect event per EIP-1193 when provider becomes disconnected
+   * @param error - Optional error that caused the disconnection
+   */
+  emitDisconnect(error) {
+    const listeners = this.eventListeners.get("disconnect");
+    if (listeners) {
+      const disconnectError = error || { code: 4900, message: "Disconnected" };
+      listeners.forEach((callback) => callback(disconnectError));
+    }
+  }
+  /* SWITCH CHAIN METHODS */
+  async attemptSwitchChain(hexChainId) {
+    await this.rpcProvider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: hexChainId }]
+    });
+  }
+  async handleMissingChain(hexChainId, chain) {
+    try {
+      await this.addChain(chain);
+      await this.attemptSwitchChain(hexChainId);
+    } catch (addError) {
+      if (isChainExistsError(addError)) {
+        await this.attemptSwitchChain(hexChainId);
+      } else {
+        throw addError;
+      }
+    }
+  }
+  async addChain(chain) {
+    if (!_optionalChain([chain, 'optionalAccess', _160 => _160.id]) || !_optionalChain([chain, 'optionalAccess', _161 => _161.name]) || !_optionalChain([chain, 'optionalAccess', _162 => _162.nativeCurrency]) || !_optionalChain([chain, 'optionalAccess', _163 => _163.rpcUrls, 'optionalAccess', _164 => _164.default, 'optionalAccess', _165 => _165.http])) {
+      throw new Error("Invalid chain configuration: missing required properties");
+    }
+    await this.rpcProvider.request({
+      method: "wallet_addEthereumChain",
+      params: [
+        {
+          chainId: `0x${chain.id.toString(16)}`,
+          chainName: chain.name,
+          nativeCurrency: chain.nativeCurrency,
+          rpcUrls: chain.rpcUrls.default.http,
+          blockExplorerUrls: chain.blockExplorers ? [chain.blockExplorers.default.url] : void 0
+        }
+      ]
+    });
+  }
+  /* REST */
+  resetConnectionState() {
+    _chunkDHEVW7CRjs.useAurumStore.getState().clearConnection();
+    this.connectedWalletAdapter = null;
+    this.updateProvider(this.skeletonProvider);
+    this.userInfo = void 0;
+  }
+};
+// Singleton instance
+_AurumCore.instance = null;
+// Events managed by AurumCore (not forwarded to underlying provider)
+_AurumCore.MANAGED_EVENTS = ["accountsChanged", "connect", "disconnect"];
+var AurumCore = _AurumCore;
+
+// src/Aurum.ts
+var Aurum = class {
+  /**
+   * Creates a new Aurum instance.
+   *
+   * @param config - Configuration for branding and wallets
+   *
+   * @example
+   * ```typescript
+   * const aurum = new Aurum({
+   *   brand: { appName: 'Your App Name' },
+   *   wallets: {
+   *     email: { projectId: 'cdp-project-id' },
+   *     walletConnect: { projectId: 'reown-project-id' },
+   *   },
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.core = new AurumCore(config);
+  }
+  /**
+   * EIP1193 compatible RPC provider that can be used to interact with the connected wallet.
+   * Compatible with viem, ethers.js, and other web3 libraries.
+   *
+   * @example
+   * ```typescript
+   * const balance = await aurum.rpcProvider.request({
+   *   method: 'eth_getBalance',
+   *   params: [address, 'latest']
+   * });
+   * ```
+   */
+  get rpcProvider() {
+    return this.core.rpcProvider;
+  }
+  /**
+   * Indicates whether the SDK is finished initializing.
+   */
+  get ready() {
+    return this.core.ready;
+  }
+  /**
+   * Returns the resolved brand configuration.
+   * @internal Used by widget components (i.e. ConnectWidget)
+   */
+  get brandConfig() {
+    return this.core.resolvedBrandConfig;
+  }
+  /**
+   * Returns the wallet adapters configured for this instance.
+   * @internal Used by widget components (i.e. ConnectWidget)
+   */
+  get walletAdapters() {
+    return this.core.walletAdapters;
+  }
+  /**
+   * Returns the set of excluded wallet IDs.
+   * @internal Used by widget components (i.e. ConnectWidget)
+   */
+  get excludedWalletIds() {
+    return this.core.excludedWalletIds;
+  }
+  /**
+   * Waits for the SDK to finish initializing.
+   * This should be called before calling methods with the provider to ensure provider is set (such as after a page refresh).
+   *
+   * @example
+   * ```typescript
+   * await aurum.whenReady();
+   * const balance = await aurum.rpcProvider.request({
+   *   method: 'eth_getBalance',
+   *   params: [address, 'latest']
+   * });
+   * ```
+   */
+  async whenReady() {
+    return this.core.whenReady();
+  }
+  /**
+   * 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' or 'walletconnect' (use their dedicated methods).
+   * @returns The connected wallet address
+   * @throws Error if user closes the modal without connecting a wallet
+   *
+   * @example
+   * ```typescript
+   * // Open modal for user to choose
+   * const address = await aurum.connect();
+   *
+   * // Or connect directly to a specific wallet
+   * import { WalletId } from '@aurum-sdk/types';
+   * const address = await aurum.connect(WalletId.MetaMask);
+   * ```
+   */
+  async connect(walletId) {
+    return this.core.connect(walletId);
+  }
+  /**
+   * Disconnects the currently connected wallet and clears the connection state.
+   *
+   * @example
+   * ```typescript
+   * await aurum.disconnect();
+   * ```
+   */
+  async disconnect() {
+    return this.core.disconnect();
+  }
+  /**
+   * Gets information about the currently connected user.
+   *
+   * @returns User information including wallet address and wallet name, or undefined if no wallet is connected
+   *
+   * @example
+   * ```typescript
+   * const userInfo = await aurum.getUserInfo();
+   * if (userInfo) {
+   *   console.log(`Connected to ${userInfo.walletName}: ${userInfo.publicAddress}`);
+   * } else {
+   *   console.log('No wallet connected');
+   * }
+   * ```
+   */
+  async getUserInfo() {
+    return this.core.getUserInfo();
+  }
+  /**
+   * Checks if a wallet is currently connected.
+   *
+   * @returns `true` if a wallet is connected, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * const isConnected = await aurum.isConnected();
+   * console.log('Is user connected:', isConnected);
+   * ```
+   */
+  async isConnected() {
+    return this.core.isConnected();
+  }
+  /**
+   * Gets the current chain ID of the connected wallet.
+   *
+   * @returns The current chain ID as a number
+   *
+   * @example
+   * ```typescript
+   * const chainId = await aurum.getChainId();
+   * console.log('Connected to chain:', chainId);
+   * ```
+   */
+  async getChainId() {
+    return this.core.getChainId();
+  }
+  /**
+   * Switches the connected wallet to a different blockchain network.
+   * If the chain is not added to the wallet, it will attempt to add it using the provided chain config.
+   *
+   * @param chainId - The chain ID to switch to (can be hex string, decimal string, or number)
+   * @param chain - Optional viem Chain object with chain configuration (required if chain needs to be added)
+   * @throws Error if the switch fails or the user rejects the request
+   *
+   * @example
+   * ```typescript
+   * import { sepolia } from 'viem/chains';
+   *
+   * await aurum.switchChain(sepolia.id, sepolia);
+   * ```
+   */
+  async switchChain(chainId, chain) {
+    return this.core.switchChain(chainId, chain);
+  }
+  /**
+   * Updates the brand configuration at runtime.
+   * Changes will be reflected the next time the connect modal is opened.
+   *
+   * @param newConfig - Partial brand config to merge with existing config
+   *
+   * @example
+   * ```typescript
+   * aurum.updateBrandConfig({
+   *   theme: 'light',
+   * });
+   * ```
+   */
+  updateBrandConfig(newConfig) {
+    this.core.updateBrandConfig(newConfig);
+  }
+  /**
+   * Updates the wallets configuration at runtime.
+   * Changes will be reflected the next time the connect modal is opened.
+   *
+   * @param newConfig - Partial wallets config to update (currently supports `exclude`)
+   *
+   * @example
+   * ```typescript
+   * import { WalletId } from '@aurum-sdk/types';
+   *
+   * aurum.updateWalletsConfig({
+   *   exclude: [WalletId.Email, WalletId.AppKit],
+   * });
+   * ```
+   */
+  updateWalletsConfig(newConfig) {
+    this.core.updateWalletsConfig(newConfig);
+  }
+  /**
+   * Notifies the SDK of a widget-initiated connection.
+   * Updates internal state so getUserInfo(), isConnected(), etc. work correctly.
+   * @internal Used by ConnectWidget - not intended for direct use
+   */
+  async handleWidgetConnection(result) {
+    return this.core.handleWidgetConnection(result);
+  }
+  /* ===== HEADLESS / WHITELABEL API ===== */
+  /**
+   * Starts the email authentication flow by sending an OTP to the provided email.
+   * Use with `emailAuthVerify()` to complete the connection.
+   *
+   * @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 configured
+   *
+   * @example
+   * ```typescript
+   * const { flowId } = await aurum.emailAuthStart('user@example.com');
+   * // User receives OTP email, then verify:
+   * const { address, email, isNewUser } = await aurum.emailAuthVerify(flowId, '123456');
+   * ```
+   */
+  async emailAuthStart(email) {
+    return this.core.emailAuthStart(email);
+  }
+  /**
+   * Verifies the email OTP and completes the wallet connection.
+   *
+   * @param flowId - The flowId returned from emailAuthStart
+   * @param otp - The OTP code the user received via email
+   * @returns Object containing the connected address and email
+   * @throws Error if verification fails
+   *
+   * @example
+   * ```typescript
+   * const { flowId } = await aurum.emailAuthStart('user@example.com');
+   * // User receives OTP...
+   * const { address, email, isNewUser } = await aurum.emailAuthVerify(flowId, '123456');
+   * console.log(`Connected: ${address} (${email})`);
+   * ```
+   */
+  async emailAuthVerify(flowId, otp) {
+    return this.core.emailAuthVerify(flowId, otp);
+  }
+  /**
+   * Initiates a WalletConnect session and returns the URI for displaying a custom QR code.
+   * 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 configured
+   *
+   * @example
+   * ```typescript
+   * // Get the WalletConnect URI
+   * const { uri, waitForConnection } = await aurum.getWalletConnectSession();
+   *
+   * // Display your custom QR code with the URI
+   * myQRCodeComponent.render(uri);
+   *
+   * // Wait for user to scan and approve
+   * const address = await waitForConnection();
+   * console.log('Connected:', address);
+   * ```
+   */
+  async getWalletConnectSession() {
+    return this.core.getWalletConnectSession();
+  }
+};
+
+
+exports.Aurum = Aurum;
+//# sourceMappingURL=index.js.map