@worldcoin/minikit-js 1.9.10 → 2.0.0-dev.0

package/build/chunk-OTAA7OOI.js

@@ -0,0 +1,835 @@
+import {
+  EventManager,
+  MiniKitInstallErrorMessage,
+  chat,
+  getPermissions,
+  isInWorldApp,
+  pay,
+  requestPermission,
+  sendHapticFeedback,
+  sendMiniKitEvent,
+  sendTransaction,
+  share,
+  shareContacts,
+  signMessage,
+  signTypedData,
+  validateCommands,
+  walletAuth
+} from "./chunk-DIACPBCB.js";
+
+// src/helpers/microphone.ts
+var microphoneSetupDone = false;
+var setupMicrophone = () => {
+  if (microphoneSetupDone) {
+    return;
+  }
+  if (typeof navigator !== "undefined" && !navigator.mediaDevices?.getUserMedia)
+    return;
+  const originalStop = MediaStreamTrack.prototype.stop;
+  MediaStreamTrack.prototype.stop = function() {
+    originalStop.call(this);
+    if (this.readyState === "ended") {
+      setTimeout(() => this.dispatchEvent(new Event("ended")), 0);
+    }
+  };
+  const realGUM = navigator.mediaDevices.getUserMedia.bind(
+    navigator.mediaDevices
+  );
+  const live = /* @__PURE__ */ new Set();
+  async function wrapped(constraints) {
+    const stream = await realGUM(constraints);
+    const hasAudioTrack = stream.getAudioTracks().length > 0;
+    if (hasAudioTrack) {
+      sendMiniKitEvent({
+        command: "microphone-stream-started",
+        version: 1,
+        payload: {
+          streamId: stream.id
+        }
+      });
+      live.add(stream);
+      stream.getAudioTracks().forEach((t) => {
+        t.addEventListener("ended", () => {
+          const allAudioTracksEnded = stream.getAudioTracks().every((track) => track.readyState === "ended");
+          if (allAudioTracksEnded) {
+            sendMiniKitEvent({
+              command: "microphone-stream-ended",
+              version: 1,
+              payload: {
+                streamId: stream.id
+              }
+            });
+            live.delete(stream);
+          }
+        });
+      });
+    }
+    return stream;
+  }
+  Object.defineProperty(navigator.mediaDevices, "getUserMedia", {
+    value: wrapped,
+    writable: false,
+    configurable: false,
+    enumerable: true
+  });
+  Object.freeze(navigator.mediaDevices);
+  const stopAllMiniAppMicrophoneStreams = () => {
+    live.forEach((s) => {
+      const audioTracks = s.getAudioTracks();
+      if (audioTracks.length > 0) {
+        audioTracks.forEach((t) => {
+          t.stop();
+        });
+        sendMiniKitEvent({
+          command: "microphone-stream-ended",
+          version: 1,
+          payload: {
+            streamId: s.id
+          }
+        });
+      }
+    });
+    live.clear();
+  };
+  MiniKit.subscribe("miniapp-microphone" /* MiniAppMicrophone */, (payload) => {
+    if (payload.status === "error" && (payload.error_code === "mini_app_permission_not_enabled" /* MiniAppPermissionNotEnabled */ || payload.error_code === "world_app_permission_not_enabled" /* WorldAppPermissionNotEnabled */)) {
+      console.log("stopping all microphone streams", payload);
+      stopAllMiniAppMicrophoneStreams();
+    }
+  });
+  window.__stopAllMiniAppMicrophoneStreams = stopAllMiniAppMicrophoneStreams;
+  microphoneSetupDone = true;
+};
+
+// src/helpers/usernames.ts
+var getUserProfile = async (address) => {
+  const res = await fetch("https://usernames.worldcoin.org/api/v1/query", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      addresses: [address]
+    })
+  });
+  const usernames = await res.json();
+  return usernames?.[0] ?? { username: null, profile_picture_url: null };
+};
+
+// src/minikit.ts
+var MINIKIT_VERSION = 1;
+var MINIKIT_MINOR_VERSION = 96;
+var WORLD_APP_LAUNCH_LOCATION_MAP = {
+  "app-store": "app-store" /* AppStore */,
+  carousel: "app-store" /* AppStore */,
+  explore: "app-store" /* AppStore */,
+  app_details: "app-store" /* AppStore */,
+  deeplink: "deep-link" /* DeepLink */,
+  homepage: "home" /* Home */,
+  wallet_tab: "wallet-tab" /* WalletTab */,
+  world_chat: "chat" /* Chat */
+};
+function mapWorldAppLaunchLocation(location) {
+  if (!location || typeof location !== "string") return null;
+  console.log("MiniKit launch location mapped:", location);
+  return WORLD_APP_LAUNCH_LOCATION_MAP[location.toLowerCase()] ?? null;
+}
+var _MiniKit = class _MiniKit {
+  static getActiveMiniKit() {
+    if (typeof window === "undefined") return this;
+    const candidate = window.MiniKit;
+    if (candidate && typeof candidate.trigger === "function") {
+      return candidate;
+    }
+    return this;
+  }
+  // ============================================================================
+  // Unified API (auto-detects environment)
+  // ============================================================================
+  /**
+   * Authenticate user via wallet signature (SIWE)
+   *
+   * Works in World App (native SIWE) and web (Wagmi + SIWE fallback).
+   *
+   * @example
+   * ```typescript
+   * const result = await MiniKit.walletAuth({ nonce: 'randomnonce123' });
+   * console.log(result.data.address);
+   * console.log(result.executedWith); // 'minikit' | 'wagmi' | 'fallback'
+   * ```
+   */
+  static walletAuth(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.walletAuth(options);
+    }
+    return walletAuth(options, this.getContext());
+  }
+  /**
+   * Send one or more transactions
+   *
+   * World App: batch + permit2 + gas sponsorship
+   * Web: sequential execution via Wagmi
+   *
+   * @example
+   * ```typescript
+   * const result = await MiniKit.sendTransaction({
+   *   chainId: 480,
+   *   transaction: [{
+   *     address: '0x...',
+   *     abi: ContractABI,
+   *     functionName: 'mint',
+   *     args: [],
+   *   }],
+   * });
+   * ```
+   */
+  static sendTransaction(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.sendTransaction(options);
+    }
+    return sendTransaction(options, this.getContext());
+  }
+  /**
+   * Send a payment (World App only)
+   *
+   * Requires custom fallback on web.
+   *
+   * @example
+   * ```typescript
+   * const result = await MiniKit.pay({
+   *   reference: crypto.randomUUID(),
+   *   to: '0x...',
+   *   tokens: [{ symbol: Tokens.WLD, token_amount: '1.0' }],
+   *   description: 'Payment for coffee',
+   *   fallback: () => showStripeCheckout(),
+   * });
+   * ```
+   */
+  static pay(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.pay(options);
+    }
+    return pay(options, this.getContext());
+  }
+  /**
+   * Open the contact picker (World App only)
+   *
+   * Requires custom fallback on web.
+   *
+   * @example
+   * ```typescript
+   * const result = await MiniKit.shareContacts({
+   *   isMultiSelectEnabled: true,
+   *   fallback: () => showManualAddressInput(),
+   * });
+   * ```
+   */
+  static shareContacts(options = {}) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.shareContacts(options);
+    }
+    return shareContacts(options, this.getContext());
+  }
+  /**
+   * Sign a message
+   */
+  static signMessage(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.signMessage(options);
+    }
+    return signMessage(options, this.getContext());
+  }
+  /**
+   * Sign typed data (EIP-712)
+   */
+  static signTypedData(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.signTypedData(options);
+    }
+    return signTypedData(options, this.getContext());
+  }
+  /**
+   * Send a chat message
+   */
+  static chat(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.chat(options);
+    }
+    return chat(options, this.getContext());
+  }
+  /**
+   * Share files/text/URL
+   */
+  static share(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.share(options);
+    }
+    return share(options, this.getContext());
+  }
+  /**
+   * Get current permission settings
+   */
+  static getPermissions(options = {}) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.getPermissions(options);
+    }
+    return getPermissions(options, this.getContext());
+  }
+  /**
+   * Request a permission from the user
+   */
+  static requestPermission(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.requestPermission(options);
+    }
+    return requestPermission(options, this.getContext());
+  }
+  /**
+   * Trigger haptic feedback
+   */
+  static sendHapticFeedback(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.sendHapticFeedback(options);
+    }
+    return sendHapticFeedback(options, this.getContext());
+  }
+  // ============================================================================
+  // Public State Accessors
+  // ============================================================================
+  static get appId() {
+    return this._appId;
+  }
+  static set appId(value) {
+    this._appId = value;
+  }
+  static get user() {
+    return this._user;
+  }
+  static set user(value) {
+    this._user = value;
+  }
+  static get deviceProperties() {
+    return this._deviceProperties;
+  }
+  static get location() {
+    return this._location;
+  }
+  // ============================================================================
+  // Event System
+  // ============================================================================
+  static subscribe(event, handler) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      active.subscribe(event, handler);
+      return;
+    }
+    if (event === "miniapp-wallet-auth" /* MiniAppWalletAuth */) {
+      const originalHandler = handler;
+      const wrappedHandler = async (payload) => {
+        if (payload.status === "success") {
+          await this.updateUserFromWalletAuth(payload.address);
+        }
+        originalHandler(payload);
+      };
+      this.eventManager.subscribe(event, wrappedHandler);
+    } else {
+      this.eventManager.subscribe(event, handler);
+    }
+  }
+  static unsubscribe(event) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      active.unsubscribe(event);
+      return;
+    }
+    this.eventManager.unsubscribe(event);
+  }
+  static trigger(event, payload) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      active.trigger(event, payload);
+      return;
+    }
+    this.eventManager.trigger(event, payload);
+  }
+  // ============================================================================
+  // Installation
+  // ============================================================================
+  static sendInit() {
+    sendMiniKitEvent({
+      command: "init",
+      payload: {
+        version: MINIKIT_VERSION,
+        minorVersion: MINIKIT_MINOR_VERSION
+      }
+    });
+  }
+  static install(appId) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.install(appId);
+    }
+    if (typeof window === "undefined") {
+      return {
+        success: false,
+        errorCode: "already_installed" /* AlreadyInstalled */,
+        errorMessage: MiniKitInstallErrorMessage["already_installed" /* AlreadyInstalled */]
+      };
+    }
+    if (!appId) {
+      console.warn("App ID not provided during install");
+    } else {
+      this._appId = appId;
+    }
+    if (!window.WorldApp) {
+      return {
+        success: false,
+        errorCode: "outside_of_worldapp" /* OutsideOfWorldApp */,
+        errorMessage: MiniKitInstallErrorMessage["outside_of_worldapp" /* OutsideOfWorldApp */]
+      };
+    }
+    this.initFromWorldApp(window.WorldApp);
+    try {
+      window.MiniKit = this;
+      this.sendInit();
+    } catch (error) {
+      console.error(
+        MiniKitInstallErrorMessage["unknown" /* Unknown */],
+        error
+      );
+      return {
+        success: false,
+        errorCode: "unknown" /* Unknown */,
+        errorMessage: MiniKitInstallErrorMessage["unknown" /* Unknown */]
+      };
+    }
+    this._isReady = true;
+    setupMicrophone();
+    if (!validateCommands(window.WorldApp.supported_commands)) {
+      return {
+        success: false,
+        errorCode: "app_out_of_date" /* AppOutOfDate */,
+        errorMessage: MiniKitInstallErrorMessage["app_out_of_date" /* AppOutOfDate */]
+      };
+    }
+    return { success: true };
+  }
+  static isInstalled(debug) {
+    const isInstalled = this._isReady && Boolean(window.MiniKit);
+    if (!isInstalled) {
+      console.warn(
+        "MiniKit is not installed. Make sure you're running the application inside of World App"
+      );
+    }
+    if (debug && isInstalled) {
+      console.log("MiniKit is alive!");
+    }
+    return isInstalled;
+  }
+  // ============================================================================
+  // Internal
+  // ============================================================================
+  static initFromWorldApp(worldApp) {
+    if (!worldApp) return;
+    this._user.optedIntoOptionalAnalytics = worldApp.is_optional_analytics;
+    this._deviceProperties.safeAreaInsets = worldApp.safe_area_insets;
+    this._deviceProperties.deviceOS = worldApp.device_os;
+    this._deviceProperties.worldAppVersion = worldApp.world_app_version;
+    this._location = mapWorldAppLaunchLocation(worldApp.location);
+  }
+  static async updateUserFromWalletAuth(address) {
+    this._user.walletAddress = address;
+    try {
+      const userProfile = await getUserProfile(address);
+      this._user.username = userProfile.username;
+      this._user.profilePictureUrl = userProfile.profile_picture_url;
+    } catch (error) {
+      console.error("Failed to fetch user profile:", error);
+    }
+  }
+  static getContext() {
+    return {
+      events: this.eventManager,
+      state: { deviceProperties: this._deviceProperties }
+    };
+  }
+  // ============================================================================
+  // Deprecated — remove in next major
+  // ============================================================================
+  /**
+   * @deprecated Use `MiniKit.pay()`, `MiniKit.walletAuth()`, etc. directly.
+   *
+   * Migration guide:
+   * - `MiniKit.commands.pay(payload)` → `await MiniKit.pay(options)`
+   * - `MiniKit.commands.walletAuth(payload)` → `await MiniKit.walletAuth(options)`
+   * - `MiniKit.commands.sendTransaction(payload)` → `await MiniKit.sendTransaction(options)`
+   * - `MiniKit.commands.signMessage(payload)` → `await MiniKit.signMessage(input)`
+   * - `MiniKit.commands.signTypedData(payload)` → `await MiniKit.signTypedData(input)`
+   * - `MiniKit.commands.shareContacts(payload)` → `await MiniKit.shareContacts(options)`
+   * - `MiniKit.commands.chat(payload)` → `await MiniKit.chat(input)`
+   * - `MiniKit.commands.share(payload)` → `await MiniKit.share(input)`
+   * - `MiniKit.commands.getPermissions()` → `await MiniKit.getPermissions()`
+   * - `MiniKit.commands.requestPermission(payload)` → `await MiniKit.requestPermission(input)`
+   * - `MiniKit.commands.sendHapticFeedback(payload)` → `await MiniKit.sendHapticFeedback(input)`
+   */
+  static get commands() {
+    throw new Error(
+      "MiniKit.commands has been removed. Use MiniKit.pay(), MiniKit.walletAuth(), etc. directly."
+    );
+  }
+  /**
+   * @deprecated Use `MiniKit.pay()`, `MiniKit.walletAuth()`, etc. directly. All commands are now async by default.
+   *
+   * See `MiniKit.commands` deprecation notice for the full migration guide.
+   */
+  static get commandsAsync() {
+    throw new Error(
+      "MiniKit.commandsAsync has been removed. Use MiniKit.pay(), MiniKit.walletAuth(), etc. directly."
+    );
+  }
+};
+_MiniKit.eventManager = new EventManager();
+// State (was MiniKitState)
+_MiniKit._appId = null;
+_MiniKit._user = {};
+_MiniKit._deviceProperties = {};
+_MiniKit._location = null;
+_MiniKit._isReady = false;
+/**
+ * Check if running inside World App
+ */
+_MiniKit.isInWorldApp = isInWorldApp;
+// ============================================================================
+// Utility Methods
+// ============================================================================
+_MiniKit.getUserByAddress = async (address) => {
+  const walletAddress = address ?? _MiniKit._user.walletAddress;
+  const userProfile = await getUserProfile(walletAddress);
+  return {
+    walletAddress,
+    username: userProfile.username,
+    profilePictureUrl: userProfile.profile_picture_url
+  };
+};
+_MiniKit.getUserByUsername = async (username) => {
+  const res = await fetch(
+    `https://usernames.worldcoin.org/api/v1/${username}`,
+    {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    }
+  );
+  const user = await res.json();
+  return {
+    walletAddress: user.address,
+    username: user.username,
+    profilePictureUrl: user.profile_picture_url
+  };
+};
+_MiniKit.getUserInfo = _MiniKit.getUserByAddress;
+_MiniKit.getMiniAppUrl = (appId, path) => {
+  const baseUrl = new URL("https://world.org/mini-app");
+  baseUrl.searchParams.append("app_id", appId);
+  if (path) {
+    const fullPath = path.startsWith("/") ? path : `/${path}`;
+    baseUrl.searchParams.append("path", encodeURIComponent(fullPath));
+  }
+  return baseUrl.toString();
+};
+_MiniKit.showProfileCard = (username, walletAddress) => {
+  if (!username && !walletAddress) {
+    console.error(
+      "Either username or walletAddress must be provided to show profile card"
+    );
+    return;
+  }
+  if (username) {
+    window.open(
+      `worldapp://profile?username=${encodeURIComponent(username)}`
+    );
+  } else {
+    window.open(
+      `worldapp://profile?address=${encodeURIComponent(walletAddress || "")}`
+    );
+  }
+};
+var MiniKit = _MiniKit;
+
+// src/provider.ts
+function _getAddress() {
+  if (typeof window === "undefined") return void 0;
+  return window.__worldapp_eip1193_address__;
+}
+function _setAddress(addr) {
+  if (typeof window === "undefined") return;
+  window.__worldapp_eip1193_address__ = addr;
+}
+function _clearAddress() {
+  if (typeof window === "undefined") return;
+  window.__worldapp_eip1193_address__ = void 0;
+}
+function rpcError(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+function isHexString(value) {
+  return /^0x[0-9a-fA-F]*$/.test(value);
+}
+function isAddressString(value) {
+  return /^0x[0-9a-fA-F]{40}$/.test(value);
+}
+function decodeHexToUtf8(hex) {
+  const raw = hex.slice(2);
+  if (raw.length % 2 !== 0) {
+    throw new Error("Invalid hex string length");
+  }
+  const bytes = new Uint8Array(raw.length / 2);
+  for (let i = 0; i < raw.length; i += 2) {
+    bytes[i / 2] = parseInt(raw.slice(i, i + 2), 16);
+  }
+  return new TextDecoder().decode(bytes);
+}
+function asArrayParams(params) {
+  if (params === void 0) return [];
+  return Array.isArray(params) ? params : [params];
+}
+function decodeMaybeHexMessage(value) {
+  if (!isHexString(value)) {
+    return value;
+  }
+  try {
+    return decodeHexToUtf8(value);
+  } catch {
+    return value;
+  }
+}
+function extractPersonalSignMessage(params) {
+  const items = asArrayParams(params);
+  if (items.length === 0) {
+    throw new Error("Missing personal_sign params");
+  }
+  const [first, second] = items;
+  const maybeMessage = typeof first === "string" && isAddressString(first) && typeof second === "string" ? second : first;
+  if (typeof maybeMessage !== "string") {
+    throw new Error("Invalid personal_sign message payload");
+  }
+  return decodeMaybeHexMessage(maybeMessage);
+}
+function extractEthSignMessage(params) {
+  const items = asArrayParams(params);
+  if (items.length === 0) {
+    throw new Error("Missing eth_sign params");
+  }
+  const [first, second] = items;
+  const maybeMessage = typeof second === "string" ? second : typeof first === "string" && !isAddressString(first) ? first : void 0;
+  if (typeof maybeMessage !== "string") {
+    throw new Error("Invalid eth_sign message payload");
+  }
+  return decodeMaybeHexMessage(maybeMessage);
+}
+function parseTypedDataInput(params) {
+  const items = asArrayParams(params);
+  const candidate = items.length > 1 ? items[1] : items[0];
+  if (!candidate) {
+    throw new Error("Missing typed data payload");
+  }
+  const parsed = typeof candidate === "string" ? JSON.parse(candidate) : candidate;
+  if (!parsed || typeof parsed !== "object" || typeof parsed.primaryType !== "string" || typeof parsed.message !== "object" || !parsed.message || typeof parsed.types !== "object" || !parsed.types) {
+    throw new Error("Invalid typed data payload");
+  }
+  const domainValue = parsed.domain;
+  const chainIdValue = domainValue?.chainId ?? parsed.chainId;
+  const parsedChainId = typeof chainIdValue === "string" ? Number(chainIdValue) : typeof chainIdValue === "number" ? chainIdValue : void 0;
+  return {
+    types: parsed.types,
+    primaryType: parsed.primaryType,
+    domain: domainValue,
+    message: parsed.message,
+    ...Number.isFinite(parsedChainId) ? { chainId: parsedChainId } : {}
+  };
+}
+function normalizeRpcValue(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "bigint") return `0x${value.toString(16)}`;
+  if (typeof value === "number") return `0x${value.toString(16)}`;
+  return String(value);
+}
+function extractTransactionParams(params) {
+  const items = asArrayParams(params);
+  const tx = items[0] ?? {};
+  if (typeof tx.to !== "string" || !isAddressString(tx.to)) {
+    throw new Error('Invalid transaction "to" address');
+  }
+  const chainId = typeof tx.chainId === "string" ? Number(tx.chainId) : typeof tx.chainId === "number" ? tx.chainId : void 0;
+  const normalizedValue = normalizeRpcValue(tx.value);
+  return {
+    to: tx.to,
+    ...typeof tx.data === "string" ? { data: tx.data } : {},
+    ...normalizedValue !== void 0 ? { value: normalizedValue } : {},
+    ...Number.isFinite(chainId) ? { chainId } : {}
+  };
+}
+function extractSwitchChainId(params) {
+  const items = asArrayParams(params);
+  const payload = items[0] ?? {};
+  const rawChainId = payload.chainId;
+  const chainId = typeof rawChainId === "string" ? Number(rawChainId) : typeof rawChainId === "number" ? rawChainId : NaN;
+  if (!Number.isFinite(chainId)) {
+    throw new Error("Invalid chainId for wallet_switchEthereumChain");
+  }
+  return chainId;
+}
+function createProvider() {
+  const listeners = {};
+  function emit(event, ...args) {
+    listeners[event]?.forEach((fn) => fn(...args));
+  }
+  let authInFlight;
+  async function doAuth() {
+    if (!MiniKit.isInWorldApp()) {
+      throw rpcError(4900, "World App provider only works inside World App");
+    }
+    try {
+      const result = await MiniKit.walletAuth({
+        nonce: crypto.randomUUID().replace(/-/g, ""),
+        statement: "Sign in with World App"
+      });
+      const addr = result.data.address;
+      _setAddress(addr);
+      emit("accountsChanged", [addr]);
+      return [addr];
+    } catch (e) {
+      throw rpcError(4001, `World App wallet auth failed: ${e.message}`);
+    }
+  }
+  return {
+    async request({ method, params }) {
+      switch (method) {
+        case "eth_requestAccounts": {
+          const existing = _getAddress();
+          if (existing) return [existing];
+          if (!authInFlight) {
+            authInFlight = doAuth().finally(() => {
+              authInFlight = void 0;
+            });
+          }
+          return authInFlight;
+        }
+        case "eth_accounts": {
+          const addr = _getAddress();
+          return addr ? [addr] : [];
+        }
+        case "eth_chainId":
+          return "0x1e0";
+        // 480 = World Chain
+        case "personal_sign": {
+          const message = extractPersonalSignMessage(params);
+          try {
+            const result = await MiniKit.signMessage({ message });
+            return result.data.signature;
+          } catch (e) {
+            throw rpcError(4001, `Sign message failed: ${e.message}`);
+          }
+        }
+        case "eth_sign": {
+          const message = extractEthSignMessage(params);
+          try {
+            const result = await MiniKit.signMessage({ message });
+            return result.data.signature;
+          } catch (e) {
+            throw rpcError(4001, `Sign message failed: ${e.message}`);
+          }
+        }
+        case "eth_signTypedData":
+        case "eth_signTypedData_v3":
+        case "eth_signTypedData_v4": {
+          try {
+            const typedData = parseTypedDataInput(params);
+            const result = await MiniKit.signTypedData({
+              types: typedData.types,
+              primaryType: typedData.primaryType,
+              domain: typedData.domain,
+              message: typedData.message,
+              chainId: typedData.chainId
+            });
+            if (result.data.status === "error") {
+              throw rpcError(
+                4001,
+                `Sign typed data failed: ${result.data.error_code}`
+              );
+            }
+            return result.data.signature;
+          } catch (e) {
+            throw rpcError(4001, `Sign typed data failed: ${e.message}`);
+          }
+        }
+        case "eth_sendTransaction": {
+          const tx = extractTransactionParams(params);
+          try {
+            const result = await MiniKit.sendTransaction({
+              ...tx.chainId !== void 0 ? { chainId: tx.chainId } : {},
+              transaction: [
+                {
+                  address: tx.to,
+                  ...tx.data && tx.data !== "0x" ? { data: tx.data } : {},
+                  value: tx.value
+                }
+              ]
+            });
+            return result.data.transactionId;
+          } catch (e) {
+            throw rpcError(4001, `Send transaction failed: ${e.message}`);
+          }
+        }
+        case "wallet_switchEthereumChain": {
+          const chainId = extractSwitchChainId(params);
+          if (chainId !== 480) {
+            throw rpcError(4902, "World App only supports World Chain (480)");
+          }
+          return null;
+        }
+        case "wallet_addEthereumChain": {
+          throw rpcError(4200, "World App only supports World Chain (480)");
+        }
+        default:
+          throw rpcError(4200, `Unsupported method: ${method}`);
+      }
+    },
+    on(event, fn) {
+      (listeners[event] ?? (listeners[event] = /* @__PURE__ */ new Set())).add(fn);
+    },
+    removeListener(event, fn) {
+      listeners[event]?.delete(fn);
+    }
+  };
+}
+function getWorldAppProvider() {
+  if (typeof window === "undefined") {
+    return createProvider();
+  }
+  if (!window.__worldapp_eip1193_provider__) {
+    window.__worldapp_eip1193_provider__ = createProvider();
+  }
+  return window.__worldapp_eip1193_provider__;
+}
+
+export {
+  MiniKit,
+  _getAddress,
+  _setAddress,
+  _clearAddress,
+  getWorldAppProvider
+};