@aurum-sdk/core 0.2.8 → 0.3.0

package/dist/RabbyAdapter-SOLYF74M.js

@@ -0,0 +1,146 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkXUD6VNF7js = require('./chunk-XUD6VNF7.js');
+
+
+var _chunkQIPVNM7Tjs = require('./chunk-QIPVNM7T.js');
+
+// src/wallet-adapters/RabbyAdapter.ts
+_chunkQIPVNM7Tjs.init_polyfills.call(void 0, );
+var RABBY_RDNS = "io.rabby";
+var RabbyAdapter = class {
+  constructor() {
+    this.id = _chunkXUD6VNF7js.WalletId.Rabby;
+    this.name = _chunkXUD6VNF7js.WalletName.Rabby;
+    this.icon = _nullishCoalesce(_chunkXUD6VNF7js.getLogoDataUri.call(void 0, _chunkXUD6VNF7js.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', _ => _.isRabby])) {
+      return ethereum;
+    }
+    return null;
+  }
+  isInstalled() {
+    return Boolean(_nullishCoalesce(this.provider, () => ( this.detectLegacyProvider())));
+  }
+  async connect() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      _chunkXUD6VNF7js.sentryLogger.error("Rabby is not available");
+      throw new Error("Rabby is not available");
+    }
+    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]) {
+      _chunkXUD6VNF7js.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) {
+      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 (e) {
+      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', _2 => _2.provider, 'optionalAccess', _3 => _3.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _4 => _4.provider, 'access', _5 => _5.removeListener, 'optionalCall', _6 => _6("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _7 => _7.provider, 'optionalAccess', _8 => _8.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+
+exports.RabbyAdapter = RabbyAdapter;
+//# sourceMappingURL=RabbyAdapter-SOLYF74M.js.map

package/dist/WalletConnectAdapter-5YL5KFGI.mjs

@@ -0,0 +1,540 @@
+import {
+  createConfigError
+} from "./chunk-4S5E6KOY.mjs";
+import {
+  WalletId,
+  WalletName,
+  getLogoDataUri,
+  sentryLogger
+} from "./chunk-RRUPCUSZ.mjs";
+import {
+  init_polyfills
+} from "./chunk-J6XFKNJN.mjs";
+
+// src/wallet-adapters/WalletConnectAdapter.ts
+init_polyfills();
+
+// src/constants/adapters.ts
+init_polyfills();
+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 = WalletId.WalletConnect;
+    this.name = WalletName.WalletConnect;
+    this.icon = getLogoDataUri(WalletId.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;
+  }
+};
+export {
+  WalletConnectAdapter
+};
+//# sourceMappingURL=WalletConnectAdapter-5YL5KFGI.mjs.map