@aurum-sdk/core 0.2.8 → 0.3.0

package/dist/EmailAdapter-RUV6JG6Z.mjs

@@ -0,0 +1,212 @@
+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/EmailAdapter.ts
+init_polyfills();
+var _EmailAdapter = class _EmailAdapter {
+  constructor(config) {
+    this.id = WalletId.Email;
+    this.name = WalletName.Email;
+    this.icon = getLogoDataUri(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 = config?.projectId || "";
+    this.telemetry = config?.telemetry ?? false;
+  }
+  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 createConfigError("Email");
+    }
+    await this.ensureInitialized();
+    if (!this.provider) {
+      sentryLogger.error("Email is not available");
+      throw new Error("Email is not available");
+    }
+    const { signInWithEmail } = await import("./index.web-NX7JZBIY.mjs");
+    const authResult = await signInWithEmail({ email });
+    return authResult;
+  }
+  async emailAuthVerify(flowId, otp) {
+    if (!flowId || !otp) {
+      throw new Error("flowId and otp are required");
+    }
+    await this.ensureInitialized();
+    if (!this.provider) {
+      sentryLogger.error("Email provider not initialized");
+      throw new Error("Email provider not initialized");
+    }
+    const { verifyEmailOTP } = await import("./index.web-NX7JZBIY.mjs");
+    return verifyEmailOTP({ flowId, otp });
+  }
+  async connect() {
+    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 {
+      return null;
+    }
+  }
+  async disconnect() {
+    try {
+      await this.ensureInitialized();
+      const { signOut } = await import("./index.web-NX7JZBIY.mjs");
+      await signOut();
+    } catch {
+    }
+  }
+  getProvider() {
+    return this.provider;
+  }
+  static async initializeChainData() {
+    if (this.chainIdMap !== null) return;
+    const [allChains, { http }] = await Promise.all([import("viem/chains"), import("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 import("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 import("./index.web-NX7JZBIY.mjs");
+    await initialize({
+      projectId: this.projectId,
+      ethereum: {
+        createOnLogin: "eoa"
+      },
+      disableAnalytics: !this.telemetry
+    });
+    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 import("./index.web-NX7JZBIY.mjs");
+      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(err?.message || "");
+            const isUnsupported = msg.includes("not supported") || msg.includes("Unsupported") || err?.code === -32601;
+            if (isUnsupported) {
+              let chainId;
+              try {
+                const chainIdHex = await base.request({ method: "eth_chainId", params: [] });
+                chainId = parseInt(chainIdHex, 16);
+              } catch {
+                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) {
+      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;
+export {
+  EmailAdapter
+};
+//# sourceMappingURL=EmailAdapter-RUV6JG6Z.mjs.map

package/dist/EmailAdapter-SY65VHGK.js

@@ -0,0 +1,212 @@
+"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 _chunkQOCN4F47js = require('./chunk-QOCN4F47.js');
+
+
+
+
+
+var _chunkXUD6VNF7js = require('./chunk-XUD6VNF7.js');
+
+
+var _chunkQIPVNM7Tjs = require('./chunk-QIPVNM7T.js');
+
+// src/wallet-adapters/EmailAdapter.ts
+_chunkQIPVNM7Tjs.init_polyfills.call(void 0, );
+var _EmailAdapter = class _EmailAdapter {
+  constructor(config) {
+    this.id = _chunkXUD6VNF7js.WalletId.Email;
+    this.name = _chunkXUD6VNF7js.WalletName.Email;
+    this.icon = _nullishCoalesce(_chunkXUD6VNF7js.getLogoDataUri.call(void 0, _chunkXUD6VNF7js.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', _ => _.projectId]) || "";
+    this.telemetry = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _2 => _2.telemetry]), () => ( false));
+  }
+  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 _chunkQOCN4F47js.createConfigError.call(void 0, "Email");
+    }
+    await this.ensureInitialized();
+    if (!this.provider) {
+      _chunkXUD6VNF7js.sentryLogger.error("Email is not available");
+      throw new Error("Email is not available");
+    }
+    const { signInWithEmail } = await Promise.resolve().then(() => _interopRequireWildcard(require("./index.web-OPNRZHYZ.js")));
+    const authResult = await signInWithEmail({ email });
+    return authResult;
+  }
+  async emailAuthVerify(flowId, otp) {
+    if (!flowId || !otp) {
+      throw new Error("flowId and otp are required");
+    }
+    await this.ensureInitialized();
+    if (!this.provider) {
+      _chunkXUD6VNF7js.sentryLogger.error("Email provider not initialized");
+      throw new Error("Email provider not initialized");
+    }
+    const { verifyEmailOTP } = await Promise.resolve().then(() => _interopRequireWildcard(require("./index.web-OPNRZHYZ.js")));
+    return verifyEmailOTP({ flowId, otp });
+  }
+  async connect() {
+    _chunkXUD6VNF7js.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 (e) {
+      return null;
+    }
+  }
+  async disconnect() {
+    try {
+      await this.ensureInitialized();
+      const { signOut } = await Promise.resolve().then(() => _interopRequireWildcard(require("./index.web-OPNRZHYZ.js")));
+      await signOut();
+    } catch (e2) {
+    }
+  }
+  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("./index.web-OPNRZHYZ.js")));
+    await initialize({
+      projectId: this.projectId,
+      ethereum: {
+        createOnLogin: "eoa"
+      },
+      disableAnalytics: !this.telemetry
+    });
+    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("./index.web-OPNRZHYZ.js")));
+      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', _3 => _3.message]) || "");
+            const isUnsupported = msg.includes("not supported") || msg.includes("Unsupported") || _optionalChain([err, 'optionalAccess', _4 => _4.code]) === -32601;
+            if (isUnsupported) {
+              let chainId;
+              try {
+                const chainIdHex = await base.request({ method: "eth_chainId", params: [] });
+                chainId = parseInt(chainIdHex, 16);
+              } catch (e3) {
+                _chunkXUD6VNF7js.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) {
+      _chunkXUD6VNF7js.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;
+
+
+exports.EmailAdapter = EmailAdapter;
+//# sourceMappingURL=EmailAdapter-SY65VHGK.js.map

package/dist/MetaMaskAdapter-4V3XM6J2.js

@@ -0,0 +1,152 @@
+"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/MetaMaskAdapter.ts
+_chunkQIPVNM7Tjs.init_polyfills.call(void 0, );
+var METAMASK_RDNS = "io.metamask";
+var MetaMaskAdapter = class {
+  constructor() {
+    this.id = _chunkXUD6VNF7js.WalletId.MetaMask;
+    this.name = _chunkXUD6VNF7js.WalletName.MetaMask;
+    this.icon = _nullishCoalesce(_chunkXUD6VNF7js.getLogoDataUri.call(void 0, _chunkXUD6VNF7js.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', _ => _.providers, 'optionalAccess', _2 => _2.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(_nullishCoalesce(this.provider, () => ( this.detectLegacyProvider())));
+  }
+  async connect() {
+    if (!this.provider && this.providerPromise) {
+      await this.providerPromise;
+    }
+    if (!this.provider) {
+      _chunkXUD6VNF7js.sentryLogger.error("MetaMask is not available");
+      throw new Error("MetaMask 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 MetaMask");
+      throw new Error("No accounts returned from MetaMask");
+    }
+    return {
+      address: accounts[0],
+      provider: this.provider,
+      walletId: this.id
+    };
+  }
+  async tryRestoreConnection() {
+    if (!this.provider && this.providerPromise) {
+      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', _3 => _3.provider, 'optionalAccess', _4 => _4.on])) return;
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _5 => _5.provider, 'access', _6 => _6.removeListener, 'optionalCall', _7 => _7("accountsChanged", this.accountsChangedCallback)]);
+    }
+    this.accountsChangedCallback = callback;
+    this.provider.on("accountsChanged", this.accountsChangedCallback);
+  }
+  removeListeners() {
+    if (!_optionalChain([this, 'access', _8 => _8.provider, 'optionalAccess', _9 => _9.removeListener]) || !this.accountsChangedCallback) return;
+    this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    this.accountsChangedCallback = null;
+  }
+};
+
+
+exports.MetaMaskAdapter = MetaMaskAdapter;
+//# sourceMappingURL=MetaMaskAdapter-4V3XM6J2.js.map