@ultraos/wallet-sdk 0.3.1 → 0.6.0

package/CHANGELOG.md

@@ -0,0 +1,47 @@
+# Changelog
+
+All notable changes to `@ultraos/wallet-sdk` are documented in this file.
+
+## 0.6.0
+
+### Removed
+
+- `purchaseItem()` and the `PurchaseItemType` / `PurchaseItemResult` types. Neither wallet serves it any more: the
+  extension redesign deliberately removed Ultra-platform checkout dependencies and the Web Wallet never shipped the
+  route, so calls could only hang until the user closed the popup.
+- `addNetwork()`. The extension removed its dApp-callable route in the v4 security audit (N-N1): adding a network
+  without an explicit approval screen is a silent RPC-takeover vector. Users add custom networks in the wallet's
+  Settings → Networks; dApps can then call `switchNetwork()`.
+
+### Changed
+
+- Corrected the `ConnectResult.blockchainid` documentation: it is the connected account **name** (equal to
+  `selectedAccount.accountName`), not a network identifier.
+- Declared the `nonce` / `signedNonce` fields every wallet already returns from `connect({ nonce })`.
+- Marked the connect-time attestation surface (`ConnectAttestation`, `ConnectResult.attestation`,
+  `ConnectParams.requireAttestation`) `@experimental`: only the browser extension issues it and no Ultra service
+  consumes it yet.
+- Published as a bundled ES module (`dist/index.mjs` + `exports` map), as in 0.3.2, now produced reproducibly by
+  `npm run build:wallet-sdk`.
+
+## 0.5.0
+
+### Added
+
+- `requireAttestation?: boolean` on `ConnectParams`. When set, a dApp signals that it needs a connect-time identity
+  attestation; if the wallet supports attestation but the origin hasn't yet consented, the wallet prompts for consent
+  via the existing connect prompt (no separate signature dialog) and resolves `connect()` with a populated
+  `ConnectResult.attestation`. Strictly additive and pass-through — the SDK forwards the flag to the wallet verbatim and
+  performs no logic on it; wallets without attestation support ignore it. Omitting it preserves existing behavior. See
+  the RFC:
+  <https://github.com/ultraio/ultra-tool-kit/blob/feature/ai-enhancement/docs/proposals/wallet-native-attestation.md>
+
+## 0.4.0
+
+### Added
+
+- `ConnectAttestation` type and an optional `attestation` field on `ConnectResult`. When the connected wallet supports
+  silent connect-time identity attestation, `connect()` now surfaces it; otherwise `attestation` is `undefined`. This is
+  a strictly additive, type-only change — the SDK passes the value through verbatim and performs no verification. See
+  the RFC:
+  <https://github.com/ultraio/ultra-tool-kit/blob/feature/ai-enhancement/docs/proposals/wallet-native-attestation.md>

package/README.md

@@ -44,7 +44,7 @@ await ultra.signTransaction({
   contract: 'eosio.token',
   action: 'transfer',
   data: { from: 'user', to: 'receiver', quantity: '1.00000000 UOS', memo: '' },
-  authorizations: ['user@active'],
+  // authorization defaults to the connected account's `active` permission
 });
 ```
 
@@ -55,7 +55,7 @@ You can pass options during initialization:
 ```ts
 new UltraWalletSDK({
   environment: 'testnet', // or 'mainnet', or provide custom URL
-  provider: 'web', // or 'extension', use a specific provider independetly of auto-detection
+  provider: 'web', // or 'extension', use a specific provider independently of auto-detection
 });
 ```
 
@@ -63,12 +63,23 @@ new UltraWalletSDK({
 
 ### Methods
 
-- `connect(): Promise<ConnectResult>`
-- `disconnect(): Promise<void>`
-- `signMessage(message: string): Promise<string>`
-- `signTransaction(transaction: BlockchainTransaction | BlockchainTransaction[]): Promise<SignTransactionResult>`
-- `getChainId(): Promise<string>`
-- `purchaseItem(itemType: PurchaseItemType, itemId: string): Promise<PurchaseItemResult>`
+All methods resolve to `UltraResponse<T>` (`{ status: 'success', data: T }`) and reject with
+`{ status, code, message }`.
+
+| Method                                                                                | Extension | Web Wallet |
+| ------------------------------------------------------------------------------------- | --------- | ---------- |
+| `connect(params?: ConnectParams)` / `disconnect()`                                    | ✅        | ✅         |
+| `signMessage(message: string)`                                                        | ✅        | ✅         |
+| `signTransaction(transaction, options?: { signOnly?: boolean })`                      | ✅        | ✅         |
+| `getChainId()`                                                                        | ✅        | ✅         |
+| `getAccounts()` / `getSelectedAccount()` / `getAvailableAuthorizations()`             | ✅        | —          |
+| `getNetwork()` / `getNetworks()` / `switchNetwork(chainId)`                           | ✅        | —          |
+| `on(event, cb)` / `off(event, cb)` — `accountChanged`, `networkChanged`, `disconnect` | ✅        | —          |
+| `dispose()`                                                                           | ✅        | ✅         |
+
+The Web Wallet is currently deployed for **mainnet** only.
+
+Full documentation: <https://developers.ultra.io/products/ultra-wallet-sdk/>
 
 ---
 

package/dist/index.mjs

@@ -0,0 +1,559 @@
+// dist/libs/wallet-sdk/src/lib/interfaces/error-enum.js
+var SdkErrorCode;
+(function(SdkErrorCode2) {
+  SdkErrorCode2[SdkErrorCode2["USER_REJECTED_REQUEST"] = 4001] = "USER_REJECTED_REQUEST";
+  SdkErrorCode2[SdkErrorCode2["WALLET_HANDSHAKE_TIMEOUT"] = 4300] = "WALLET_HANDSHAKE_TIMEOUT";
+  SdkErrorCode2[SdkErrorCode2["WALLET_WINDOW_UNAVAILABLE"] = 4301] = "WALLET_WINDOW_UNAVAILABLE";
+  SdkErrorCode2[SdkErrorCode2["REQUESTED_RESOURCE_NOT_AVAILABLE"] = 32002] = "REQUESTED_RESOURCE_NOT_AVAILABLE";
+  SdkErrorCode2[SdkErrorCode2["UNKNOWN_ERROR"] = -32604] = "UNKNOWN_ERROR";
+})(SdkErrorCode || (SdkErrorCode = {}));
+var SDK_ERROR_MESSAGE = {
+  [SdkErrorCode.USER_REJECTED_REQUEST]: "The user rejected the request.",
+  [SdkErrorCode.WALLET_HANDSHAKE_TIMEOUT]: "Timeout to connect with the web wallet.",
+  [SdkErrorCode.WALLET_WINDOW_UNAVAILABLE]: "Wallet window blocked by browser or failed to open.",
+  [SdkErrorCode.REQUESTED_RESOURCE_NOT_AVAILABLE]: "Requested resource not available.",
+  [SdkErrorCode.UNKNOWN_ERROR]: "Unknown error occurred."
+};
+
+// dist/libs/wallet-sdk/src/lib/interfaces/wallet-provider-response.interface.js
+var ResponseStatus;
+(function(ResponseStatus2) {
+  ResponseStatus2["SUCCESS"] = "success";
+  ResponseStatus2["FAIL"] = "fail";
+  ResponseStatus2["ERROR"] = "error";
+})(ResponseStatus || (ResponseStatus = {}));
+
+// dist/libs/wallet-sdk/src/lib/config/ultra-wallet-sdk.config.js
+var UltraWalletSdkConfig = Object.freeze({
+  width: 420,
+  height: 815,
+  walletUrls: {
+    mainnet: "https://web-wallet.ultra.io",
+    testnet: "https://web-wallet.staging.ultra.io"
+  },
+  networkInfo: {
+    mainnet: {
+      chainId: "a9c481dfbc7d9506dc7e87e9a137c931b0a9303f64fd7a1d08b8230133920097"
+    },
+    testnet: {
+      chainId: "7fc56be645bb76ab9d747b53089f132dcb7681db06f0852cfa03eaf6f7ac80e9"
+    }
+  },
+  checkWindowInterval: 500,
+  handshakeTimeout: 1e4
+});
+var ultra_wallet_sdk_config_default = UltraWalletSdkConfig;
+
+// dist/libs/wallet-sdk/src/lib/utils/chain-validator.js
+function isValidChain(targetNetwork, walletChainId) {
+  const { chainId } = ultra_wallet_sdk_config_default.networkInfo[targetNetwork] || {};
+  return !chainId || chainId === walletChainId;
+}
+
+// dist/libs/wallet-sdk/src/lib/providers/extension-provider/extension.provider.js
+var HEARTBEAT_INTERVAL_MS = 2e3;
+var ExtensionProvider = class {
+  /**
+   * Access window.ultra typed as UltraWalletProvider.
+   * At runtime, window.ultra is a Proxy that handles all SDK method calls.
+   * We cast here rather than declaring a global Window augmentation to avoid
+   * conflicting with the app-level window.d.ts which types window.ultra as IUltraInternalAPI.
+   */
+  get walletProvider() {
+    return window.ultra;
+  }
+  constructor(options) {
+    this.options = options;
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.listenerIds = /* @__PURE__ */ new Map();
+    this.heartbeatTimer = null;
+    this.messageHandler = null;
+    this.initWindowEventListener();
+  }
+  /**
+   * Wire-format match: the BG's MessageType.EVENT serialises as the uppercase
+   * string 'EVENT'. We uppercase the incoming type so a future SDK build that
+   * emits lowercase (or any case variant) still dispatches. Payload shape:
+   * `{ event, origin, data }`.
+   */
+  initWindowEventListener() {
+    if (typeof window === "undefined")
+      return;
+    if (this.messageHandler)
+      return;
+    this.messageHandler = (event) => {
+      if (event.source !== window || !event.data)
+        return;
+      const msg = event.data;
+      const msgType = typeof msg.type === "string" ? msg.type.toUpperCase() : "";
+      if (msgType !== "EVENT" || !msg.payload)
+        return;
+      const eventName = msg.payload.event;
+      if (!eventName)
+        return;
+      const cbs = this.eventListeners.get(eventName);
+      if (cbs)
+        cbs.forEach((cb) => cb(msg.payload.data));
+    };
+    window.addEventListener("message", this.messageHandler);
+  }
+  async connect(params) {
+    const { data: chainId } = await this.walletProvider.getChainId();
+    if (!isValidChain(this.options?.environment, chainId)) {
+      throw new Error(`Wallet environment mismatch: expected "${this.options?.environment}" chain, but received "${chainId}". Please verify the SDK configuration and the connected network.`);
+    }
+    const result = await this.walletProvider.connect(params);
+    if (result?.status === "success") {
+      this.listenerIds.clear();
+      for (const event of this.eventListeners.keys()) {
+        void this.registerListenerWithExtension(event);
+      }
+    }
+    return result;
+  }
+  disconnect() {
+    return this.walletProvider.disconnect();
+  }
+  signMessage(message) {
+    return this.walletProvider.signMessage(message);
+  }
+  signTransaction(transaction, options) {
+    return this.walletProvider.signTransaction(transaction, options);
+  }
+  getChainId() {
+    return this.walletProvider.getChainId();
+  }
+  getAccounts() {
+    return this.walletProvider.getAccounts();
+  }
+  getSelectedAccount() {
+    return this.walletProvider.getSelectedAccount();
+  }
+  getAvailableAuthorizations() {
+    return this.walletProvider.getAvailableAuthorizations();
+  }
+  on(event, callback) {
+    this.initWindowEventListener();
+    const cbs = this.eventListeners.get(event) ?? [];
+    cbs.push(callback);
+    this.eventListeners.set(event, cbs);
+    void this.registerListenerWithExtension(event);
+    this.ensureHeartbeat();
+  }
+  off(event, callback) {
+    const cbs = this.eventListeners.get(event);
+    if (!cbs)
+      return;
+    const idx = cbs.indexOf(callback);
+    if (idx >= 0)
+      cbs.splice(idx, 1);
+    if (cbs.length === 0) {
+      this.eventListeners.delete(event);
+      void this.deregisterListenerWithExtension(event);
+    }
+  }
+  switchNetwork(chainId) {
+    return this.walletProvider.switchNetwork(chainId);
+  }
+  getNetwork() {
+    return this.walletProvider.getNetwork();
+  }
+  getNetworks() {
+    return this.walletProvider.getNetworks();
+  }
+  /**
+   * Detach the window message listener and clear timers + maps. Safe to call
+   * multiple times. Does NOT deregister each listener on the BG — the BG
+   * GCs on tab close (verified via the S5(b) dedup work + tab-close cleanup
+   * in `EventsService.removeTabListeners`). Calling N RPCs at dispose-time
+   * would slow the page-unload path for no benefit.
+   */
+  dispose() {
+    if (this.heartbeatTimer != null) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.messageHandler && typeof window !== "undefined") {
+      window.removeEventListener("message", this.messageHandler);
+      this.messageHandler = null;
+    }
+    this.eventListeners.clear();
+    this.listenerIds.clear();
+  }
+  async registerListenerWithExtension(event) {
+    if (!this.isExtensionAvailable())
+      return;
+    const id = this.listenerIds.get(event) ?? this.generateListenerId();
+    this.listenerIds.set(event, id);
+    try {
+      const result = this.walletProvider.addExtensionListener?.(event, id);
+      if (result && typeof result.catch === "function") {
+        result.catch(() => void 0);
+      }
+    } catch {
+    }
+  }
+  async deregisterListenerWithExtension(event) {
+    if (!this.isExtensionAvailable())
+      return;
+    const id = this.listenerIds.get(event);
+    if (!id)
+      return;
+    this.listenerIds.delete(event);
+    try {
+      const result = this.walletProvider.removeExtensionListener?.(event, id);
+      if (result && typeof result.catch === "function") {
+        result.catch(() => void 0);
+      }
+    } catch {
+    }
+  }
+  ensureHeartbeat() {
+    if (this.heartbeatTimer != null || typeof window === "undefined")
+      return;
+    this.heartbeatTimer = setInterval(() => this.heartbeatTick(), HEARTBEAT_INTERVAL_MS);
+  }
+  heartbeatTick() {
+    if (!this.isExtensionAvailable())
+      return;
+    let hasAny = false;
+    for (const cbs of this.eventListeners.values()) {
+      if (cbs.length > 0) {
+        hasAny = true;
+        break;
+      }
+    }
+    if (!hasAny)
+      return;
+    for (const event of this.eventListeners.keys()) {
+      void this.registerListenerWithExtension(event);
+    }
+  }
+  isExtensionAvailable() {
+    return typeof window !== "undefined" && !!window.ultra;
+  }
+  generateListenerId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    return Math.random().toString(36).slice(2) + Date.now().toString(36);
+  }
+};
+
+// dist/libs/wallet-sdk/src/lib/common/client-messenger.js
+import { JSONRPCClient } from "json-rpc-2.0";
+
+// dist/libs/wallet-sdk/src/lib/common/client-error.js
+var ClientError = class extends Error {
+  constructor(code, data) {
+    super();
+    this.code = code;
+    this.data = data;
+    this.message = SDK_ERROR_MESSAGE[code];
+    this.name = this.constructor.name;
+  }
+};
+
+// dist/libs/wallet-sdk/src/lib/common/client-messenger.js
+var ClientMessenger = class {
+  constructor(windowManager) {
+    this.pendingRequest = false;
+    this.windowManager = windowManager;
+    this.initializeRpcClient();
+    this.setupMessageListener();
+  }
+  initializeRpcClient() {
+    this.rpcClient = new JSONRPCClient((request) => {
+      const walletWindow = this.windowManager.getWalletWindow();
+      if (!walletWindow) {
+        return Promise.reject(new ClientError(SdkErrorCode.WALLET_WINDOW_UNAVAILABLE));
+      }
+      walletWindow.postMessage(request, this.windowManager.walletUrl);
+      return Promise.resolve();
+    });
+  }
+  setupMessageListener() {
+    window.addEventListener("message", (event) => {
+      if (event.origin === this.windowManager.walletUrl && event.data?.jsonrpc === "2.0") {
+        this.rpcClient.receive(event.data);
+      }
+    });
+  }
+  async sendRequest(requestMethod, requestParams) {
+    if (this.pendingRequest && !this.isWalletWindowClosed()) {
+      throw this.createErrorResponse(SdkErrorCode.REQUESTED_RESOURCE_NOT_AVAILABLE);
+    }
+    this.pendingRequest = true;
+    try {
+      this.windowManager.openOrReuseWallet();
+      const walletWindow = this.ensureWalletWindow();
+      return await this.executeRequest(walletWindow, requestMethod, requestParams);
+    } finally {
+      this.pendingRequest = false;
+    }
+  }
+  isWalletWindowClosed() {
+    return this.windowManager.getWalletWindow()?.closed === true;
+  }
+  ensureWalletWindow() {
+    const walletWindow = this.windowManager.getWalletWindow();
+    if (!walletWindow) {
+      throw this.createErrorResponse(SdkErrorCode.WALLET_WINDOW_UNAVAILABLE);
+    }
+    return walletWindow;
+  }
+  async executeRequest(walletWindow, requestMethod, requestParams) {
+    await this.waitForWalletReady(walletWindow);
+    return this.processRpcRequest(walletWindow, requestMethod, requestParams);
+  }
+  async waitForWalletReady(walletWindow) {
+    return this.withWindowMonitoring(walletWindow, () => {
+      return new Promise((resolve, reject) => {
+        let isResolved = false;
+        let timeoutId;
+        const cleanup = () => {
+          if (isResolved)
+            return;
+          isResolved = true;
+          clearTimeout(timeoutId);
+          window.removeEventListener("message", handleWalletHandshake);
+        };
+        const handleWalletHandshake = (event) => {
+          if (!this.isValidReadyMessage(event))
+            return;
+          cleanup();
+          resolve();
+        };
+        const handleTimeout = () => {
+          cleanup();
+          walletWindow.close();
+          reject(this.createErrorResponse(SdkErrorCode.WALLET_HANDSHAKE_TIMEOUT));
+        };
+        window.addEventListener("message", handleWalletHandshake);
+        timeoutId = setTimeout(handleTimeout, ultra_wallet_sdk_config_default.handshakeTimeout);
+      });
+    });
+  }
+  async processRpcRequest(walletWindow, requestMethod, requestParams) {
+    return this.withWindowMonitoring(walletWindow, async () => {
+      let result;
+      try {
+        result = await this.rpcClient.request(requestMethod, requestParams);
+      } catch (error) {
+        const clientError = new ClientError(SdkErrorCode.UNKNOWN_ERROR, error);
+        throw {
+          status: ResponseStatus.ERROR,
+          ...clientError
+        };
+      } finally {
+        if (result?.status === ResponseStatus.SUCCESS) {
+          return result;
+        } else {
+          throw result;
+        }
+      }
+    });
+  }
+  async withWindowMonitoring(walletWindow, operation) {
+    return new Promise((resolve, reject) => {
+      const intervalId = setInterval(() => {
+        if (walletWindow.closed) {
+          clearInterval(intervalId);
+          reject(this.createErrorResponse(SdkErrorCode.USER_REJECTED_REQUEST));
+        }
+      }, ultra_wallet_sdk_config_default.checkWindowInterval);
+      operation().then((result) => {
+        clearInterval(intervalId);
+        resolve(result);
+      }).catch((error) => {
+        clearInterval(intervalId);
+        reject(error);
+      });
+    });
+  }
+  isValidReadyMessage(event) {
+    if (event.origin !== this.windowManager.walletUrl)
+      return false;
+    const msg = event.data;
+    return msg?.jsonrpc === "2.0" && msg.method === "ready";
+  }
+  createErrorResponse(errorCode) {
+    const { code, message } = new ClientError(errorCode);
+    return { status: ResponseStatus.ERROR, code, message, data: null };
+  }
+};
+
+// dist/libs/wallet-sdk/src/lib/common/window-manager.js
+var WindowManager = class {
+  constructor(walletUrl) {
+    this.walletWindow = null;
+    this.currentWindow = window;
+    this.walletUrl = walletUrl;
+  }
+  openOrReuseWallet() {
+    if (this.walletWindow == null || this.walletWindow.closed) {
+      const height = ultra_wallet_sdk_config_default.height;
+      const width = ultra_wallet_sdk_config_default.width;
+      const top = this.currentWindow.top;
+      const left = this.currentWindow.screenLeft + this.currentWindow.innerWidth - width;
+      this.walletWindow = window.open(this.walletUrl, "_blank", `width=${width},height=${height},top=${top},left=${left},resizable=0`);
+    } else {
+      this.walletWindow.focus();
+    }
+  }
+  // Provides a reference to the wallet window
+  getWalletWindow() {
+    return this.walletWindow;
+  }
+};
+
+// dist/libs/wallet-sdk/src/lib/providers/web-provider/web.provider.js
+var WebProvider = class {
+  constructor(options) {
+    this.options = options;
+    this.windowManager = new WindowManager(this.resolveWalletUrl());
+    this.clientMessenger = new ClientMessenger(this.windowManager);
+  }
+  connect(options) {
+    return this.clientMessenger.sendRequest("connect", { options });
+  }
+  disconnect() {
+    return this.clientMessenger.sendRequest("disconnect", {});
+  }
+  signMessage(message) {
+    return this.clientMessenger.sendRequest("signMessage", { message });
+  }
+  signTransaction(transaction, options) {
+    return this.clientMessenger.sendRequest("signTransaction", { transaction, options });
+  }
+  async getChainId() {
+    const environment = this.options?.environment || "mainnet";
+    switch (environment) {
+      case "mainnet":
+        const mainnetChainId = ultra_wallet_sdk_config_default.networkInfo.mainnet.chainId;
+        return {
+          status: ResponseStatus.SUCCESS,
+          data: mainnetChainId
+        };
+      case "testnet":
+        const testnetChainId = ultra_wallet_sdk_config_default.networkInfo.testnet.chainId;
+        return {
+          status: ResponseStatus.SUCCESS,
+          data: testnetChainId
+        };
+      default:
+        return this.clientMessenger.sendRequest("getChainId", {});
+    }
+  }
+  getAccounts() {
+    return this.clientMessenger.sendRequest("getAccounts", {});
+  }
+  getSelectedAccount() {
+    return this.clientMessenger.sendRequest("getSelectedAccount", {});
+  }
+  getAvailableAuthorizations() {
+    return this.clientMessenger.sendRequest("getAvailableAuthorizations", {});
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  on(_event, _callback) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  off(_event, _callback) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  switchNetwork(_chainId) {
+    throw new Error("Not supported in web provider");
+  }
+  getNetwork() {
+    throw new Error("Not supported in web provider");
+  }
+  getNetworks() {
+    throw new Error("Not supported in web provider");
+  }
+  dispose() {
+  }
+  resolveWalletUrl() {
+    const env = ultra_wallet_sdk_config_default.walletUrls[this.options?.environment || "mainnet"];
+    return env || this.options.environment;
+  }
+};
+
+// dist/libs/wallet-sdk/src/lib/utils/detection.js
+function isExtensionAvailable() {
+  return typeof window !== "undefined" && "ultra" in window;
+}
+
+// dist/libs/wallet-sdk/src/lib/ultra-wallet-sdk.js
+var UltraWalletSDK = class {
+  /**
+   * Constructs an UltraWalletClient instance.
+   * If the Ultra Wallet Extension is available (window.ultra), it will be used automatically.
+   * If the Extension is not available, the Web Wallet provider will be initialized using the given network options.
+   *
+   * @param {UltraWalletSdkOptions} [options] - Configuration options for the Web Wallet fallback (environment or custom URL).
+   */
+  constructor(options) {
+    this.options = options;
+    this.provider = this.resolveWalletProvider();
+  }
+  connect(params) {
+    return this.provider.connect(params);
+  }
+  disconnect() {
+    return this.provider.disconnect();
+  }
+  signMessage(message) {
+    return this.provider.signMessage(message);
+  }
+  signTransaction(transaction, options) {
+    return this.provider.signTransaction(transaction, options);
+  }
+  getChainId() {
+    return this.provider.getChainId();
+  }
+  getAccounts() {
+    return this.provider.getAccounts();
+  }
+  getSelectedAccount() {
+    return this.provider.getSelectedAccount();
+  }
+  getAvailableAuthorizations() {
+    return this.provider.getAvailableAuthorizations();
+  }
+  on(event, callback) {
+    this.provider.on(event, callback);
+  }
+  off(event, callback) {
+    this.provider.off(event, callback);
+  }
+  switchNetwork(chainId) {
+    return this.provider.switchNetwork(chainId);
+  }
+  getNetwork() {
+    return this.provider.getNetwork();
+  }
+  getNetworks() {
+    return this.provider.getNetworks();
+  }
+  dispose() {
+    this.provider.dispose();
+  }
+  resolveWalletProvider() {
+    const requestedProvider = this.options?.provider;
+    if (requestedProvider === "extension") {
+      return new ExtensionProvider(this.options);
+    }
+    if (requestedProvider === "web") {
+      return new WebProvider(this.options);
+    }
+    const extensionAvailable = isExtensionAvailable();
+    return extensionAvailable ? new ExtensionProvider(this.options) : new WebProvider(this.options);
+  }
+};
+export {
+  ResponseStatus,
+  SDK_ERROR_MESSAGE,
+  SdkErrorCode,
+  UltraWalletSDK
+};
+//# sourceMappingURL=index.mjs.map