@aurum-sdk/core 0.2.8 → 0.3.0-canary.0

package/dist/WalletConnectAdapter-NKQZY25A.js

@@ -0,0 +1,540 @@
+"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(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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 _chunkALDVMRQGjs = require('./chunk-ALDVMRQG.js');
+
+
+var _chunkQIPVNM7Tjs = require('./chunk-QIPVNM7T.js');
+
+// src/wallet-adapters/WalletConnectAdapter.ts
+_chunkQIPVNM7Tjs.init_polyfills.call(void 0, );
+
+// src/constants/adapters.ts
+_chunkQIPVNM7Tjs.init_polyfills.call(void 0, );
+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 = _optionalChain([namespaces, 'optionalAccess', _ => _.eip155, 'optionalAccess', _2 => _2.accounts]) || [];
+  const firstAccount = accounts[0];
+  return _nullishCoalesce(_optionalChain([firstAccount, 'optionalAccess', _3 => _3.split, 'call', _4 => _4(":"), 'access', _5 => _5[2]]), () => ( null));
+}
+var WalletConnectAdapter = class {
+  constructor(config) {
+    this.id = _chunkALDVMRQGjs.WalletId.WalletConnect;
+    this.name = _chunkALDVMRQGjs.WalletName.WalletConnect;
+    this.icon = _nullishCoalesce(_chunkALDVMRQGjs.getLogoDataUri.call(void 0, _chunkALDVMRQGjs.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([
+      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 = [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: _nullishCoalesce(this.config.telemetry, () => ( false))
+      }
+    });
+    this.universalProvider = await _asyncNullishCoalesce(await this.modal.getUniversalProvider(), async () => ( 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 (!_optionalChain([this, 'access', _6 => _6.wagmiAdapter, 'optionalAccess', _7 => _7.wagmiConfig])) return;
+    const { state } = this.wagmiAdapter.wagmiConfig;
+    if (state.current && state.connections) {
+      const connection = state.connections.get(state.current);
+      if (_optionalChain([connection, 'optionalAccess', _8 => _8.accounts, 'optionalAccess', _9 => _9[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', _10 => _10["eip155"]]);
+        if (eip155Provider) {
+          this.provider = eip155Provider;
+          return;
+        }
+      }
+      if (_optionalChain([this, 'access', _11 => _11.wagmiAdapter, 'optionalAccess', _12 => _12.wagmiConfig])) {
+        const { state } = this.wagmiAdapter.wagmiConfig;
+        if (state.current && state.connections) {
+          const connection = state.connections.get(state.current);
+          const connector = _optionalChain([connection, 'optionalAccess', _13 => _13.connector]);
+          if (connector && typeof connector.getProvider === "function") {
+            try {
+              const provider = await connector.getProvider();
+              if (provider) {
+                this.provider = provider;
+              }
+            } catch (error) {
+              _chunkALDVMRQGjs.sentryLogger.warn("Failed to get provider from wagmi connector", { error });
+            }
+          }
+        }
+      }
+    } catch (error) {
+      _chunkALDVMRQGjs.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 } = _optionalChain([this, 'access', _14 => _14.wagmiAdapter, 'optionalAccess', _15 => _15.wagmiConfig]) || {};
+      const connection = _optionalChain([state, 'optionalAccess', _16 => _16.current]) && _optionalChain([state, 'access', _17 => _17.connections, 'optionalAccess', _18 => _18.get, 'call', _19 => _19(state.current)]);
+      if (connection && typeof connection !== "string" && _optionalChain([connection, 'access', _20 => _20.connector, 'optionalAccess', _21 => _21.disconnect])) {
+        await connection.connector.disconnect();
+      }
+    } catch (e) {
+    }
+    if (_optionalChain([this, 'access', _22 => _22.modal, 'optionalAccess', _23 => _23.getIsConnectedState, 'call', _24 => _24()])) {
+      try {
+        await this.modal.disconnect("eip155");
+      } catch (e2) {
+      }
+    }
+    if (_optionalChain([this, 'access', _25 => _25.universalProvider, 'optionalAccess', _26 => _26.session])) {
+      try {
+        await this.universalProvider.disconnect();
+      } catch (e3) {
+      }
+    }
+    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 _chunkQOCN4F47js.createConfigError.call(void 0, "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 _chunkQOCN4F47js.createConfigError.call(void 0, "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 = () => _optionalChain([unsubscribe, 'optionalCall', _27 => _27()]);
+      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 (_optionalChain([accounts, 'optionalAccess', _28 => _28.length])) {
+              resolved = true;
+              cleanup();
+              _optionalChain([this, 'access', _29 => _29.modal, 'optionalAccess', _30 => _30.close, 'call', _31 => _31()]);
+              this.lastKnownAccounts = accounts;
+              resolve({ address: this.address, provider: this.provider, walletId: this.id });
+              return true;
+            }
+          } catch (e4) {
+          }
+        }
+        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 = _optionalChain([state, 'optionalAccess', _32 => _32.current]) && _optionalChain([state, 'access', _33 => _33.connections, 'optionalAccess', _34 => _34.get, 'call', _35 => _35(state.current)]);
+      if (!connection || typeof connection === "string") return null;
+      const address = _optionalChain([connection, 'access', _36 => _36.accounts, 'optionalAccess', _37 => _37[0]]);
+      if (address && this.provider) {
+        this.address = address;
+        this.lastKnownAccounts = [...connection.accounts || []];
+        return { address, provider: this.provider, walletId: this.id };
+      }
+      return null;
+    } catch (e5) {
+      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 && _optionalChain([this, 'access', _38 => _38.provider, 'optionalAccess', _39 => _39.removeListener])) {
+      this.provider.removeListener("accountsChanged", this.accountsChangedCallback);
+    }
+    if (this.sessionUpdateHandler && _optionalChain([this, 'access', _40 => _40.universalProvider, 'optionalAccess', _41 => _41.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 (_optionalChain([this, 'access', _42 => _42.provider, 'optionalAccess', _43 => _43.on])) {
+      this.provider.on("accountsChanged", this.accountsChangedCallback);
+    }
+    if (_optionalChain([this, 'access', _44 => _44.universalProvider, 'optionalAccess', _45 => _45.on])) {
+      this.sessionUpdateHandler = (args) => {
+        const accounts = this.extractAccountsFromNamespaces(_optionalChain([args, 'optionalAccess', _46 => _46.params, 'optionalAccess', _47 => _47.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 (!_optionalChain([this, 'access', _48 => _48.provider, 'optionalAccess', _49 => _49.on])) return;
+    if (this.chainChangedCallback) _optionalChain([this, 'access', _50 => _50.provider, 'access', _51 => _51.removeListener, 'optionalCall', _52 => _52("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) => {
+      _optionalChain([ns, 'optionalAccess', _53 => _53.accounts, 'optionalAccess', _54 => _54.forEach, 'call', _55 => _55((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() !== _optionalChain([this, 'access', _56 => _56.lastKnownAccounts, 'access', _57 => _57[i], 'optionalAccess', _58 => _58.toLowerCase, 'call', _59 => _59()]));
+  }
+  removeListeners() {
+    if (this.accountsChangedCallback) {
+      _optionalChain([this, 'access', _60 => _60.provider, 'optionalAccess', _61 => _61.removeListener, 'optionalCall', _62 => _62("accountsChanged", this.accountsChangedCallback)]);
+      this.accountsChangedCallback = null;
+    }
+    if (this.chainChangedCallback) {
+      _optionalChain([this, 'access', _63 => _63.provider, 'optionalAccess', _64 => _64.removeListener, 'optionalCall', _65 => _65("chainChanged", this.chainChangedCallback)]);
+      this.chainChangedCallback = null;
+    }
+    if (this.sessionUpdateHandler) {
+      _optionalChain([this, 'access', _66 => _66.universalProvider, 'optionalAccess', _67 => _67.removeListener, 'optionalCall', _68 => _68("session_update", this.sessionUpdateHandler)]);
+      this.sessionUpdateHandler = null;
+    }
+    this.disconnectCallback = null;
+    this.unsubscribeFunctions.forEach((unsub) => unsub());
+    this.unsubscribeFunctions = [];
+    this.lastKnownAccounts = [];
+    this.lastKnownChainId = null;
+  }
+};
+
+
+exports.WalletConnectAdapter = WalletConnectAdapter;
+//# sourceMappingURL=WalletConnectAdapter-NKQZY25A.js.map

package/dist/chunk-4S5E6KOY.mjs

@@ -0,0 +1,21 @@
+import {
+  init_polyfills
+} from "./chunk-J6XFKNJN.mjs";
+
+// src/utils/isConfigError.ts
+init_polyfills();
+var isConfigError = (error) => {
+  const name = error?.name;
+  return name === "ConfigError";
+};
+var createConfigError = (adapterName) => {
+  const error = new Error(`Missing required project ID for ${adapterName}`);
+  error.name = "ConfigError";
+  return error;
+};
+
+export {
+  isConfigError,
+  createConfigError
+};
+//# sourceMappingURL=chunk-4S5E6KOY.mjs.map