@aurum-sdk/core 0.2.6 → 0.2.7

package/dist/index.mjs

@@ -16,7 +16,7 @@ import {
   useAurumStore,
   useNavigation,
   waitForStoreHydration
-} from "./chunk-UPYYZG5D.mjs";
+} from "./chunk-64XDE56K.mjs";
 import "./chunk-DRID67T7.mjs";
 import {
   init_polyfills
@@ -1656,6 +1656,81 @@ var RpcProvider = class {
   }
 };
 
+// src/errors.ts
+init_polyfills();
+var AurumError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = this.constructor.name;
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var UserRejectedError = class extends AurumError {
+  constructor() {
+    super(...arguments);
+    this.code = "USER_REJECTED";
+  }
+};
+var ChainSwitchRejectedError = class extends AurumError {
+  constructor() {
+    super(...arguments);
+    this.code = "CHAIN_SWITCH_REJECTED";
+  }
+};
+var WalletNotInstalledError = class extends AurumError {
+  constructor(walletId, cause) {
+    super(`${walletId} is not installed`, cause);
+    this.walletId = walletId;
+    this.code = "WALLET_NOT_INSTALLED";
+  }
+};
+var WalletNotConfiguredError = class extends AurumError {
+  constructor(walletId, cause) {
+    super(`${walletId} is not configured`, cause);
+    this.walletId = walletId;
+    this.code = "WALLET_NOT_CONFIGURED";
+  }
+};
+var WalletExcludedError = class extends AurumError {
+  constructor(walletId, cause) {
+    super(`${walletId} is excluded from wallet options`, cause);
+    this.walletId = walletId;
+    this.code = "WALLET_EXCLUDED";
+  }
+};
+var ChainNotSupportedError = class extends AurumError {
+  constructor() {
+    super(...arguments);
+    this.code = "CHAIN_NOT_SUPPORTED";
+  }
+};
+var InvalidConfigError = class extends AurumError {
+  constructor() {
+    super(...arguments);
+    this.code = "INVALID_CONFIG";
+  }
+};
+var ConnectionError = class extends AurumError {
+  constructor() {
+    super(...arguments);
+    this.code = "CONNECTION_FAILED";
+  }
+};
+var USER_REJECTION_REGEX = /user (rejected|denied|cancel(l?)ed)/i;
+function normalizeError(err, context) {
+  if (err instanceof AurumError) return err;
+  const rawCode = err?.code;
+  const rawMessage = err?.message;
+  const message = typeof rawMessage === "string" ? rawMessage : "Unknown error";
+  const isRejectionCode = rawCode === 4001 || rawCode === "4001" || rawCode === "ACTION_REJECTED";
+  const isRejectionMessage = typeof rawMessage === "string" && USER_REJECTION_REGEX.test(rawMessage);
+  if (isRejectionCode || isRejectionMessage) {
+    return context?.operation === "switchChain" ? new ChainSwitchRejectedError(message, err) : new UserRejectedError(message, err);
+  }
+  return new ConnectionError(message, err);
+}
+
 // src/AurumCore.ts
 var _AurumCore = class _AurumCore {
   constructor(config) {
@@ -1664,6 +1739,26 @@ var _AurumCore = class _AurumCore {
     this.userInfo = void 0;
     this.connectedWalletAdapter = null;
     this.eventListeners = /* @__PURE__ */ new Map();
+    // EIP-1193 event listener passthroughs. Delegates to the proxy rpcProvider so listeners survive
+    // provider swaps (connect/disconnect) without consumers needing to re-register.
+    this.on = (event, listener) => {
+      this.rpcProvider.on(
+        event,
+        listener
+      );
+    };
+    this.off = (event, listener) => {
+      this.rpcProvider.removeListener(
+        event,
+        listener
+      );
+    };
+    this.removeListener = (event, listener) => {
+      this.rpcProvider.removeListener(
+        event,
+        listener
+      );
+    };
     if (_AurumCore.instance) {
       const incoming = _AurumCore.serializeConfig(config);
       if (incoming !== null && incoming !== _AurumCore.storedConfigJson) {
@@ -1717,79 +1812,87 @@ var _AurumCore = class _AurumCore {
     return this.excludedWallets;
   }
   async connect(walletId) {
-    await this.whenReady();
-    if (walletId === "email") {
-      throw new Error("Use emailAuthStart() and emailAuthVerify() for email wallet connections");
-    }
-    if (this.userInfo?.publicAddress && this.connectedWalletAdapter?.getProvider()) {
-      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`);
+    try {
+      await this.whenReady();
+      if (walletId === "email") {
+        throw new InvalidConfigError("Use emailAuthStart() and emailAuthVerify() for email wallet connections");
       }
-      adapter = this.wallets.find((w) => w.id === walletId) || null;
-      if (!adapter) {
-        throw new Error(`${walletId} is not configured`);
+      if (this.userInfo?.publicAddress && this.connectedWalletAdapter?.getProvider()) {
+        if (!walletId || this.userInfo.walletId === walletId) {
+          return this.userInfo.publicAddress;
+        }
+        await this.disconnect();
       }
-      if (walletId === WalletId.WalletConnect && adapter.openModal) {
-        result = await adapter.openModal();
+      let adapter = null;
+      let result;
+      if (walletId) {
+        if (this.excludedWallets.has(walletId)) {
+          throw new WalletExcludedError(walletId);
+        }
+        adapter = this.wallets.find((w) => w.id === walletId) || null;
+        if (!adapter) {
+          throw new WalletNotConfiguredError(walletId);
+        }
+        if (walletId === WalletId.WalletConnect && adapter.openModal) {
+          result = await adapter.openModal();
+        } else {
+          if (!adapter.isInstalled()) {
+            throw new WalletNotInstalledError(adapter.name);
+          }
+          result = await adapter.connect();
+        }
       } else {
-        if (!adapter.isInstalled()) {
-          throw new Error(`${adapter.name} is not installed`);
+        const displayedWallets = this.wallets.filter((w) => !this.excludedWallets.has(w.id));
+        const modalResult = await renderConnectModal({ displayedWallets, brandConfig: this.brandConfig });
+        if (!modalResult) {
+          sentryLogger.error("Missing modal result");
+          throw new ConnectionError("Missing modal result");
         }
-        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) {
-        sentryLogger.error("Missing modal result");
-        throw new Error("Missing modal result");
+        adapter = this.wallets.find((w) => w.id === modalResult.walletId) || null;
+        if (!adapter) {
+          sentryLogger.error(`Selected wallet adapter not found: ${modalResult.walletId}`);
+          throw new ConnectionError("Selected wallet adapter not found");
+        }
+        result = modalResult;
       }
-      adapter = this.wallets.find((w) => w.id === modalResult.walletId) || null;
-      if (!adapter) {
-        sentryLogger.error(`Selected wallet adapter not found: ${modalResult.walletId}`);
-        throw new Error("Selected wallet adapter not found");
+      const provider = result.provider ?? adapter.getProvider();
+      if (!provider) {
+        sentryLogger.error(`Error fetching provider on login: ${adapter.id}`);
+        throw new ConnectionError("Error fetching provider. Please try again.");
       }
-      result = modalResult;
-    }
-    const provider = result.provider ?? adapter.getProvider();
-    if (!provider) {
-      sentryLogger.error(`Error fetching provider on login: ${adapter.id}`);
-      throw new Error("Error fetching provider. Please try again.");
-    }
-    const checksumAdr = checksumAddress(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]);
-    sentryLogger.info(`Wallet connected: ${adapter.id} (${walletId ? "headless" : "modal"})`);
-    return checksumAdr;
+      const checksumAdr = checksumAddress(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]);
+      sentryLogger.info(`Wallet connected: ${adapter.id} (${walletId ? "headless" : "modal"})`);
+      return checksumAdr;
+    } catch (err) {
+      throw normalizeError(err, { operation: "connect" });
+    }
   }
   async disconnect() {
-    await this.whenReady();
-    if (this.connectedWalletAdapter) {
-      this.connectedWalletAdapter.removeListeners();
-      await this.connectedWalletAdapter.disconnect();
+    try {
+      await this.whenReady();
+      if (this.connectedWalletAdapter) {
+        this.connectedWalletAdapter.removeListeners();
+        await this.connectedWalletAdapter.disconnect();
+      }
+      this.resetConnectionState();
+      this.emitDisconnect();
+      this.emitAccountsChanged([]);
+    } catch (err) {
+      throw normalizeError(err, { operation: "disconnect" });
     }
-    this.resetConnectionState();
-    this.emitDisconnect();
-    this.emitAccountsChanged([]);
   }
   async getUserInfo() {
     await this.whenReady();
@@ -1802,30 +1905,34 @@ var _AurumCore = class _AurumCore {
     );
   }
   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 = result.provider ?? adapter.getProvider();
-    if (!provider) {
-      sentryLogger.error(`Error fetching provider on widget login: ${result?.walletId}`);
-      throw new Error("Error fetching provider. Please try again.");
-    }
-    const checksumAdr = checksumAddress(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]);
-    sentryLogger.info(`Wallet connected: ${adapter.id} (widget)`);
-    return this.userInfo;
+    try {
+      await this.whenReady();
+      const adapter = this.wallets.find((w) => w.id === result.walletId) || null;
+      if (!adapter) throw new ConnectionError("Selected wallet adapter not found");
+      const provider = result.provider ?? adapter.getProvider();
+      if (!provider) {
+        sentryLogger.error(`Error fetching provider on widget login: ${result?.walletId}`);
+        throw new ConnectionError("Error fetching provider. Please try again.");
+      }
+      const checksumAdr = checksumAddress(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]);
+      sentryLogger.info(`Wallet connected: ${adapter.id} (widget)`);
+      return this.userInfo;
+    } catch (err) {
+      throw normalizeError(err, { operation: "connect" });
+    }
   }
   async getChainId() {
     await this.whenReady();
@@ -1833,13 +1940,17 @@ var _AurumCore = class _AurumCore {
     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);
+      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);
+      }
+    } catch (err) {
+      throw normalizeError(err, { operation: "switchChain" });
     }
   }
   updateBrandConfig(newConfig) {
@@ -1871,13 +1982,17 @@ var _AurumCore = class _AurumCore {
    * @returns flowId to use with emailAuthVerify
    */
   async emailAuthStart(email) {
-    await this.whenReady();
-    const emailAdapter = this.wallets.find((w) => w.id === WalletId.Email);
-    if (!emailAdapter || !emailAdapter.emailAuthStart) {
-      throw new Error("Email wallet is not configured");
+    try {
+      await this.whenReady();
+      const emailAdapter = this.wallets.find((w) => w.id === WalletId.Email);
+      if (!emailAdapter || !emailAdapter.emailAuthStart) {
+        throw new WalletNotConfiguredError("email");
+      }
+      const result = await emailAdapter.emailAuthStart(email);
+      return { flowId: result.flowId };
+    } catch (err) {
+      throw normalizeError(err, { operation: "emailAuthStart" });
     }
-    const result = await emailAdapter.emailAuthStart(email);
-    return { flowId: result.flowId };
   }
   /**
    * Verifies the email OTP and completes the connection.
@@ -1886,77 +2001,89 @@ var _AurumCore = class _AurumCore {
    * @returns The connected wallet address and email
    */
   async emailAuthVerify(flowId, otp) {
-    await this.whenReady();
-    const emailAdapter = this.wallets.find((w) => w.id === 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) {
-      sentryLogger.error("Failed to get provider after email verification");
-      throw new Error("Failed to get provider after email verification");
-    }
-    const address = verifyResult.user?.evmAccounts?.[0];
-    const email = verifyResult.user?.authenticationMethods?.email?.email;
-    if (!address || !email) {
-      sentryLogger.error("Address or email not found after email verification");
-      throw new Error("Address or email not found after email verification");
-    }
-    const checksumAdr = checksumAddress(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]);
-    sentryLogger.info(`Wallet connected: ${emailAdapter.id} (headless)`);
-    return { address: checksumAdr, email: email ?? "", isNewUser: verifyResult.isNewUser ?? false };
+    try {
+      await this.whenReady();
+      const emailAdapter = this.wallets.find((w) => w.id === WalletId.Email);
+      if (!emailAdapter || !emailAdapter.emailAuthVerify) {
+        throw new WalletNotConfiguredError("email");
+      }
+      const verifyResult = await emailAdapter.emailAuthVerify(flowId, otp);
+      const provider = emailAdapter.getProvider();
+      if (!provider) {
+        sentryLogger.error("Failed to get provider after email verification");
+        throw new ConnectionError("Failed to get provider after email verification");
+      }
+      const address = verifyResult.user?.evmAccounts?.[0];
+      const email = verifyResult.user?.authenticationMethods?.email?.email;
+      if (!address || !email) {
+        sentryLogger.error("Address or email not found after email verification");
+        throw new ConnectionError("Address or email not found after email verification");
+      }
+      const checksumAdr = checksumAddress(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]);
+      sentryLogger.info(`Wallet connected: ${emailAdapter.id} (headless)`);
+      return { address: checksumAdr, email: email ?? "", isNewUser: verifyResult.isNewUser ?? false };
+    } catch (err) {
+      throw normalizeError(err, { operation: "emailAuthVerify" });
+    }
   }
   /**
    * 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 === 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 = result.provider ?? wcAdapter.getProvider();
-        if (!provider) {
-          sentryLogger.error("Failed to get provider after WalletConnect connection");
-          throw new Error("Failed to get provider after WalletConnect connection");
-        }
-        const checksumAdr = checksumAddress(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]);
-        sentryLogger.info(`Wallet connected: ${wcAdapter.id} (headless)`);
-        return checksumAdr;
+    try {
+      await this.whenReady();
+      const wcAdapter = this.wallets.find((w) => w.id === WalletId.WalletConnect);
+      if (!wcAdapter) {
+        throw new WalletNotConfiguredError("walletconnect");
       }
-    };
+      const session = await wcAdapter.startSession();
+      return {
+        uri: session.uri,
+        waitForConnection: async () => {
+          try {
+            const result = await session.waitForConnection();
+            const provider = result.provider ?? wcAdapter.getProvider();
+            if (!provider) {
+              sentryLogger.error("Failed to get provider after WalletConnect connection");
+              throw new ConnectionError("Failed to get provider after WalletConnect connection");
+            }
+            const checksumAdr = checksumAddress(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]);
+            sentryLogger.info(`Wallet connected: ${wcAdapter.id} (headless)`);
+            return checksumAdr;
+          } catch (err) {
+            throw normalizeError(err, { operation: "connect" });
+          }
+        }
+      };
+    } catch (err) {
+      throw normalizeError(err, { operation: "connect" });
+    }
   }
   /* PROVIDER METHODS */
   createProviderProxy() {
@@ -2141,7 +2268,7 @@ var _AurumCore = class _AurumCore {
   }
   async addChain(chain) {
     if (!chain?.id || !chain?.name || !chain?.nativeCurrency || !chain?.rpcUrls?.default?.http) {
-      throw new Error("Invalid chain configuration: missing required properties");
+      throw new InvalidConfigError("Invalid chain configuration: missing required properties");
     }
     await this.rpcProvider.request({
       method: "wallet_addEthereumChain",
@@ -2193,6 +2320,32 @@ var Aurum = class {
    * ```
    */
   constructor(config) {
+    /**
+     * Registers an EIP-1193 event listener on the wallet provider.
+     * Listeners survive provider swaps (connect/disconnect) so consumers register once.
+     *
+     * @example
+     * ```typescript
+     * aurum.on('accountsChanged', (accounts) => console.log(accounts));
+     * aurum.on('chainChanged', (chainId) => console.log(chainId));
+     * ```
+     */
+    this.on = (event, listener) => {
+      this.core.on(event, listener);
+    };
+    /**
+     * Removes an EIP-1193 event listener previously registered with `on()`.
+     * Alias for `removeListener`.
+     */
+    this.off = (event, listener) => {
+      this.core.off(event, listener);
+    };
+    /**
+     * Removes an EIP-1193 event listener previously registered with `on()`.
+     */
+    this.removeListener = (event, listener) => {
+      this.core.removeListener(event, listener);
+    };
     this.core = new AurumCore(config);
   }
   /**
@@ -2454,6 +2607,16 @@ var Aurum = class {
   }
 };
 export {
-  Aurum
+  Aurum,
+  AurumError,
+  ChainNotSupportedError,
+  ChainSwitchRejectedError,
+  ConnectionError,
+  InvalidConfigError,
+  UserRejectedError,
+  WalletExcludedError,
+  WalletNotConfiguredError,
+  WalletNotInstalledError,
+  normalizeError
 };
 //# sourceMappingURL=index.mjs.map

package/dist/widgets.d.mts

@@ -1,5 +1,5 @@
 import React, { RefObject } from 'react';
-import { Aurum } from './index.mjs';
+import { A as Aurum } from './Aurum-B0Okb4Qv.mjs';
 import { UserInfo, NonNullableBrandConfig } from '@aurum-sdk/types';
 import 'viem';
 import '@coinbase/cdp-core';

package/dist/widgets.d.ts

@@ -1,5 +1,5 @@
 import React, { RefObject } from 'react';
-import { Aurum } from './index.js';
+import { A as Aurum } from './Aurum-B0Okb4Qv.js';
 import { UserInfo, NonNullableBrandConfig } from '@aurum-sdk/types';
 import 'viem';
 import '@coinbase/cdp-core';