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

package/build/connector/index.cjs

@@ -0,0 +1,2388 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/connector/index.ts
+var connector_exports = {};
+__export(connector_exports, {
+  worldApp: () => worldApp
+});
+module.exports = __toCommonJS(connector_exports);
+
+// src/commands/wagmi-fallback.ts
+var SIWE_NONCE_REGEX = /^[a-zA-Z0-9]{8,}$/;
+var WAGMI_KEY = "__minikit_wagmi_config__";
+function setWagmiConfig(config) {
+  globalThis[WAGMI_KEY] = config;
+}
+function getWagmiConfig() {
+  return globalThis[WAGMI_KEY];
+}
+function hasWagmiConfig() {
+  return globalThis[WAGMI_KEY] !== void 0;
+}
+async function ensureConnected(config) {
+  const { connect, getConnections } = await import("wagmi/actions");
+  const isWorldApp = typeof window !== "undefined" && Boolean(window.WorldApp);
+  const existingConnection = getConnections(config).find(
+    (connection) => connection.accounts && connection.accounts.length > 0 && (isWorldApp || connection.connector?.id !== "worldApp")
+  );
+  if (existingConnection && existingConnection.accounts) {
+    return existingConnection.accounts[0];
+  }
+  const connectors = config.connectors;
+  if (!connectors || connectors.length === 0) {
+    throw new Error("No Wagmi connectors configured");
+  }
+  const candidateConnectors = isWorldApp ? connectors : connectors.filter(
+    (connector) => connector.id !== "worldApp"
+  );
+  if (!isWorldApp && candidateConnectors.length === 0) {
+    throw new Error(
+      "No web Wagmi connectors configured. Add a web connector (e.g. injected or walletConnect) after worldApp()."
+    );
+  }
+  const selectedConnector = candidateConnectors[0];
+  try {
+    const result = await connect(config, { connector: selectedConnector });
+    if (result.accounts.length > 0) {
+      const account = result.accounts[0];
+      const address = typeof account === "string" ? account : account.address;
+      if (address) {
+        return address;
+      }
+    }
+  } catch (error) {
+    const connectorId = selectedConnector.id ?? "unknown";
+    const wrappedError = new Error(
+      `Failed to connect with connector "${connectorId}". Reorder connectors to change the default connector.`
+    );
+    wrappedError.cause = error;
+    throw wrappedError;
+  }
+  throw new Error("Failed to connect wallet");
+}
+async function wagmiWalletAuth(params) {
+  const config = getWagmiConfig();
+  if (!config) {
+    throw new Error(
+      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
+    );
+  }
+  const { signMessage: signMessage2 } = await import("wagmi/actions");
+  const { SiweMessage } = await import("siwe");
+  const address = await ensureConnected(config);
+  if (!SIWE_NONCE_REGEX.test(params.nonce)) {
+    throw new Error(
+      "Invalid nonce: must be alphanumeric and at least 8 characters (EIP-4361)"
+    );
+  }
+  const siweMessage = new SiweMessage({
+    domain: typeof window !== "undefined" ? window.location.host : "localhost",
+    address,
+    statement: params.statement,
+    uri: typeof window !== "undefined" ? window.location.origin : "http://localhost",
+    version: "1",
+    chainId: 480,
+    // World Chain
+    nonce: params.nonce,
+    expirationTime: params.expirationTime?.toISOString()
+  });
+  const message = siweMessage.prepareMessage();
+  const signature = await signMessage2(config, { message });
+  return {
+    address,
+    message,
+    signature
+  };
+}
+async function wagmiSignMessage(params) {
+  const config = getWagmiConfig();
+  if (!config) {
+    throw new Error(
+      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
+    );
+  }
+  const { signMessage: signMessage2 } = await import("wagmi/actions");
+  const address = await ensureConnected(config);
+  const signature = await signMessage2(config, {
+    account: address,
+    message: params.message
+  });
+  return {
+    status: "success",
+    version: 1,
+    signature,
+    address
+  };
+}
+async function wagmiSignTypedData(params) {
+  const config = getWagmiConfig();
+  if (!config) {
+    throw new Error(
+      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
+    );
+  }
+  const { getChainId, signTypedData: signTypedData2, switchChain } = await import("wagmi/actions");
+  const address = await ensureConnected(config);
+  if (params.chainId !== void 0) {
+    const currentChainId = await getChainId(config);
+    if (currentChainId !== params.chainId) {
+      await switchChain(config, { chainId: params.chainId });
+    }
+  }
+  const signature = await signTypedData2(config, {
+    account: address,
+    types: params.types,
+    primaryType: params.primaryType,
+    domain: params.domain,
+    message: params.message
+  });
+  return {
+    status: "success",
+    version: 1,
+    signature,
+    address
+  };
+}
+function isChainMismatchError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("does not match the target chain");
+}
+async function wagmiSendTransaction(params) {
+  const config = getWagmiConfig();
+  if (!config) {
+    throw new Error(
+      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
+    );
+  }
+  const { getChainId, getWalletClient, sendTransaction: sendTransaction2, switchChain } = await import("wagmi/actions");
+  await ensureConnected(config);
+  const targetChainId = params.chainId ?? config.chains?.[0]?.id;
+  const ensureTargetChain = async () => {
+    if (targetChainId === void 0) return;
+    const currentChainId = await getChainId(config);
+    if (currentChainId !== targetChainId) {
+      await switchChain(config, { chainId: targetChainId });
+    }
+    const walletClient = await getWalletClient(config);
+    const providerChainId = walletClient ? await walletClient.getChainId() : await getChainId(config);
+    if (providerChainId !== targetChainId) {
+      throw new Error(
+        `Wallet network mismatch: expected chain ${targetChainId}, got ${providerChainId}. Please switch networks in your wallet and retry.`
+      );
+    }
+  };
+  await ensureTargetChain();
+  let transactionHash;
+  try {
+    transactionHash = await sendTransaction2(config, {
+      chainId: targetChainId,
+      to: params.transaction.address,
+      data: params.transaction.data,
+      value: params.transaction.value ? BigInt(params.transaction.value) : void 0
+    });
+  } catch (error) {
+    if (targetChainId === void 0 || !isChainMismatchError(error)) {
+      throw error;
+    }
+    await ensureTargetChain();
+    transactionHash = await sendTransaction2(config, {
+      chainId: targetChainId,
+      to: params.transaction.address,
+      data: params.transaction.data,
+      value: params.transaction.value ? BigInt(params.transaction.value) : void 0
+    });
+  }
+  return { transactionHash };
+}
+
+// src/commands/types.ts
+var COMMAND_VERSIONS = {
+  ["pay" /* Pay */]: 1,
+  ["wallet-auth" /* WalletAuth */]: 2,
+  ["send-transaction" /* SendTransaction */]: 1,
+  ["sign-message" /* SignMessage */]: 1,
+  ["sign-typed-data" /* SignTypedData */]: 1,
+  ["share-contacts" /* ShareContacts */]: 1,
+  ["request-permission" /* RequestPermission */]: 1,
+  ["get-permissions" /* GetPermissions */]: 1,
+  ["send-haptic-feedback" /* SendHapticFeedback */]: 1,
+  ["share" /* Share */]: 1,
+  ["chat" /* Chat */]: 1
+};
+var commandAvailability = {
+  ["pay" /* Pay */]: false,
+  ["wallet-auth" /* WalletAuth */]: false,
+  ["send-transaction" /* SendTransaction */]: false,
+  ["sign-message" /* SignMessage */]: false,
+  ["sign-typed-data" /* SignTypedData */]: false,
+  ["share-contacts" /* ShareContacts */]: false,
+  ["request-permission" /* RequestPermission */]: false,
+  ["get-permissions" /* GetPermissions */]: false,
+  ["send-haptic-feedback" /* SendHapticFeedback */]: false,
+  ["share" /* Share */]: false,
+  ["chat" /* Chat */]: false
+};
+function isCommandAvailable(command) {
+  return commandAvailability[command] ?? false;
+}
+function setCommandAvailable(command, available) {
+  commandAvailability[command] = available;
+}
+function validateCommands(worldAppSupportedCommands) {
+  let allCommandsValid = true;
+  Object.entries(COMMAND_VERSIONS).forEach(([commandName, version]) => {
+    const commandInput = worldAppSupportedCommands.find(
+      (cmd) => cmd.name === commandName
+    );
+    let isCommandValid = false;
+    if (!commandInput) {
+      console.warn(
+        `Command ${commandName} is not supported by the app. Try updating the app version`
+      );
+    } else {
+      if (commandInput.supported_versions.includes(version)) {
+        setCommandAvailable(commandName, true);
+        isCommandValid = true;
+      } else {
+        isCommandValid = true;
+        console.warn(
+          `Command ${commandName} version ${version} is not supported by the app. Supported versions: ${commandInput.supported_versions.join(", ")}. This is not an error, but it is recommended to update the World App version.`
+        );
+        setCommandAvailable(commandName, true);
+      }
+    }
+    if (!isCommandValid) {
+      allCommandsValid = false;
+    }
+  });
+  return allCommandsValid;
+}
+function sendMiniKitEvent(payload) {
+  if (window.webkit) {
+    window.webkit?.messageHandlers?.minikit?.postMessage?.(payload);
+  } else if (window.Android) {
+    window.Android?.postMessage?.(JSON.stringify(payload));
+  }
+}
+function isInWorldApp() {
+  return typeof window !== "undefined" && Boolean(window.WorldApp);
+}
+var FallbackRequiredError = class extends Error {
+  constructor(command) {
+    super(
+      `${command} requires a fallback function when running outside World App. Provide a fallback option: MiniKit.${command}({ ..., fallback: () => yourFallback() })`
+    );
+    this.name = "FallbackRequiredError";
+  }
+};
+var CommandUnavailableError = class extends Error {
+  constructor(command, reason) {
+    const messages = {
+      notInWorldApp: "Not running inside World App",
+      commandNotSupported: "Command not supported in this environment",
+      oldAppVersion: "World App version does not support this command"
+    };
+    super(`${command} is unavailable: ${messages[reason]}`);
+    this.name = "CommandUnavailableError";
+    this.reason = reason;
+  }
+};
+
+// src/events.ts
+var EventManager = class {
+  constructor() {
+    this.listeners = {
+      ["miniapp-payment" /* MiniAppPayment */]: () => {
+      },
+      ["miniapp-wallet-auth" /* MiniAppWalletAuth */]: () => {
+      },
+      ["miniapp-send-transaction" /* MiniAppSendTransaction */]: () => {
+      },
+      ["miniapp-sign-message" /* MiniAppSignMessage */]: () => {
+      },
+      ["miniapp-sign-typed-data" /* MiniAppSignTypedData */]: () => {
+      },
+      ["miniapp-share-contacts" /* MiniAppShareContacts */]: () => {
+      },
+      ["miniapp-request-permission" /* MiniAppRequestPermission */]: () => {
+      },
+      ["miniapp-get-permissions" /* MiniAppGetPermissions */]: () => {
+      },
+      ["miniapp-send-haptic-feedback" /* MiniAppSendHapticFeedback */]: () => {
+      },
+      ["miniapp-share" /* MiniAppShare */]: () => {
+      },
+      ["miniapp-microphone" /* MiniAppMicrophone */]: () => {
+      },
+      ["miniapp-chat" /* MiniAppChat */]: () => {
+      }
+    };
+  }
+  subscribe(event, handler) {
+    this.listeners[event] = handler;
+  }
+  unsubscribe(event) {
+    delete this.listeners[event];
+  }
+  trigger(event, payload) {
+    if (!this.listeners[event]) {
+      console.error(
+        `No handler for event ${event}, payload: ${JSON.stringify(payload)}`
+      );
+      return;
+    }
+    this.listeners[event](payload);
+  }
+};
+
+// src/commands/fallback.ts
+async function executeWithFallback(options) {
+  const {
+    command,
+    nativeExecutor,
+    wagmiFallback,
+    customFallback,
+    requiresFallback = false
+  } = options;
+  const inWorldApp = isInWorldApp();
+  const commandAvailable = isCommandAvailable(command);
+  let nativeError;
+  if (inWorldApp && commandAvailable) {
+    try {
+      const data = await nativeExecutor();
+      return { data, executedWith: "minikit" };
+    } catch (error) {
+      nativeError = error;
+      console.warn(`Native ${command} failed, attempting fallback:`, error);
+    }
+  }
+  if (!inWorldApp && wagmiFallback && hasWagmiConfig()) {
+    try {
+      const data = await wagmiFallback();
+      return { data, executedWith: "wagmi" };
+    } catch (error) {
+      console.warn(`Wagmi fallback for ${command} failed:`, error);
+    }
+  }
+  if (customFallback) {
+    const data = await customFallback();
+    return { data, executedWith: "fallback" };
+  }
+  if (nativeError) {
+    throw nativeError;
+  }
+  if (requiresFallback && !inWorldApp) {
+    throw new FallbackRequiredError(command);
+  }
+  throw new CommandUnavailableError(command, determineFallbackReason(command));
+}
+function determineFallbackReason(command) {
+  if (!isInWorldApp()) {
+    return "notInWorldApp";
+  }
+  if (!isCommandAvailable(command)) {
+    return "oldAppVersion";
+  }
+  return "commandNotSupported";
+}
+
+// src/commands/chat/types.ts
+var ChatError = class extends Error {
+  constructor(error_code) {
+    super(`Chat failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "ChatError";
+  }
+};
+
+// src/commands/chat/index.ts
+async function chat(options, ctx) {
+  const result = await executeWithFallback({
+    command: "chat" /* Chat */,
+    nativeExecutor: () => nativeChat(options, ctx),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeChat(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("chat" /* Chat */)) {
+    throw new Error(
+      "'chat' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payloadInput = {
+    message: options.message,
+    to: options.to
+  };
+  if (payloadInput.message.length === 0) {
+    throw new Error("'chat' command requires a non-empty message");
+  }
+  const payload = await new Promise((resolve, reject) => {
+    try {
+      ctx.events.subscribe("miniapp-chat" /* MiniAppChat */, (response) => {
+        ctx.events.unsubscribe("miniapp-chat" /* MiniAppChat */);
+        resolve(response);
+      });
+      sendMiniKitEvent({
+        command: "chat" /* Chat */,
+        version: COMMAND_VERSIONS["chat" /* Chat */],
+        payload: payloadInput
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  if (payload.status === "error") {
+    throw new ChatError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/get-permissions/types.ts
+var GetPermissionsError = class extends Error {
+  constructor(error_code) {
+    super(`Get permissions failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "GetPermissionsError";
+  }
+};
+
+// src/commands/get-permissions/index.ts
+async function getPermissions(options, ctx) {
+  const resolvedOptions = options ?? {};
+  const result = await executeWithFallback({
+    command: "get-permissions" /* GetPermissions */,
+    nativeExecutor: () => nativeGetPermissions(ctx),
+    customFallback: resolvedOptions.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeGetPermissions(ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("get-permissions" /* GetPermissions */)) {
+    throw new Error(
+      "'getPermissions' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-get-permissions" /* MiniAppGetPermissions */, (response) => {
+          ctx.events.unsubscribe("miniapp-get-permissions" /* MiniAppGetPermissions */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "get-permissions" /* GetPermissions */,
+          version: COMMAND_VERSIONS["get-permissions" /* GetPermissions */],
+          payload: {}
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (payload.status === "error") {
+    throw new GetPermissionsError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/pay/types.ts
+var PayError = class extends Error {
+  constructor(code) {
+    super(`Payment failed: ${code}`);
+    this.name = "PayError";
+    this.code = code;
+  }
+};
+
+// src/commands/pay/validate.ts
+var validatePaymentPayload = (payload) => {
+  if (payload.tokens.some(
+    (token) => token.symbol == "USDCE" /* USDC */ && parseFloat(token.token_amount) < 0.1
+  )) {
+    console.error("USDC amount should be greater than $0.1");
+    return false;
+  }
+  if (payload.reference.length > 36) {
+    console.error("Reference must not exceed 36 characters");
+    return false;
+  }
+  if (typeof payload.reference !== "string") {
+    throw new Error("Reference must be a string");
+  }
+  return true;
+};
+
+// src/commands/pay/index.ts
+async function pay(options, ctx) {
+  const result = await executeWithFallback({
+    command: "pay" /* Pay */,
+    nativeExecutor: () => nativePay(options, ctx),
+    // No Wagmi fallback - pay is native only
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return { executedWith: "minikit", data: result.data };
+}
+async function nativePay(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("pay" /* Pay */)) {
+    throw new Error(
+      "'pay' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const input = {
+    reference: options.reference,
+    to: options.to,
+    tokens: options.tokens,
+    description: options.description,
+    network: options.network
+  };
+  if (!validatePaymentPayload(input)) {
+    throw new Error("Invalid payment payload");
+  }
+  const eventPayload = {
+    ...input,
+    network: "worldchain" /* WorldChain */
+  };
+  const finalPayload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-payment" /* MiniAppPayment */, (response) => {
+          ctx.events.unsubscribe("miniapp-payment" /* MiniAppPayment */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "pay" /* Pay */,
+          version: COMMAND_VERSIONS["pay" /* Pay */],
+          payload: eventPayload
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (finalPayload.status === "error") {
+    throw new PayError(finalPayload.error_code);
+  }
+  return {
+    transactionId: finalPayload.transaction_id,
+    reference: finalPayload.reference,
+    from: finalPayload.from,
+    chain: finalPayload.chain,
+    timestamp: finalPayload.timestamp
+  };
+}
+
+// src/commands/request-permission/types.ts
+var RequestPermissionError = class extends Error {
+  constructor(error_code) {
+    super(`Request permission failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "RequestPermissionError";
+  }
+};
+
+// src/commands/request-permission/index.ts
+async function requestPermission(options, ctx) {
+  const result = await executeWithFallback({
+    command: "request-permission" /* RequestPermission */,
+    nativeExecutor: () => nativeRequestPermission(options, ctx),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeRequestPermission(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("request-permission" /* RequestPermission */)) {
+    throw new Error(
+      "'requestPermission' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-request-permission" /* MiniAppRequestPermission */, (response) => {
+          ctx.events.unsubscribe("miniapp-request-permission" /* MiniAppRequestPermission */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "request-permission" /* RequestPermission */,
+          version: COMMAND_VERSIONS["request-permission" /* RequestPermission */],
+          payload: { permission: options.permission }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (payload.status === "error") {
+    throw new RequestPermissionError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/send-haptic-feedback/types.ts
+var SendHapticFeedbackError = class extends Error {
+  constructor(error_code) {
+    super(`Send haptic feedback failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "SendHapticFeedbackError";
+  }
+};
+
+// src/commands/send-haptic-feedback/index.ts
+async function sendHapticFeedback(options, ctx) {
+  const result = await executeWithFallback({
+    command: "send-haptic-feedback" /* SendHapticFeedback */,
+    nativeExecutor: () => nativeSendHapticFeedback(options, ctx),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeSendHapticFeedback(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("send-haptic-feedback" /* SendHapticFeedback */)) {
+    throw new Error(
+      "'sendHapticFeedback' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payloadInput = options.hapticsType === "selection-changed" ? { hapticsType: "selection-changed" } : options.hapticsType === "impact" ? {
+    hapticsType: "impact",
+    style: options.style
+  } : {
+    hapticsType: "notification",
+    style: options.style
+  };
+  const payload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-send-haptic-feedback" /* MiniAppSendHapticFeedback */, (response) => {
+          ctx.events.unsubscribe("miniapp-send-haptic-feedback" /* MiniAppSendHapticFeedback */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "send-haptic-feedback" /* SendHapticFeedback */,
+          version: COMMAND_VERSIONS["send-haptic-feedback" /* SendHapticFeedback */],
+          payload: payloadInput
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (payload.status === "error") {
+    throw new SendHapticFeedbackError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/send-transaction/index.ts
+var import_viem = require("viem");
+
+// src/commands/send-transaction/types.ts
+var SendTransactionError = class extends Error {
+  constructor(code, details) {
+    super(`Transaction failed: ${code}`);
+    this.name = "SendTransactionError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/commands/send-transaction/validate.ts
+var isValidHex = (str) => {
+  return /^0x[0-9A-Fa-f]+$/.test(str);
+};
+var objectValuesToArrayRecursive = (input) => {
+  if (input === null || typeof input !== "object") {
+    return input;
+  }
+  if (Array.isArray(input)) {
+    return input.map((item) => objectValuesToArrayRecursive(item));
+  }
+  const values = Object.values(input);
+  return values.map((value) => objectValuesToArrayRecursive(value));
+};
+var processPayload = (payload) => {
+  if (typeof payload === "boolean" || typeof payload === "string" || payload === null || payload === void 0) {
+    return payload;
+  }
+  if (typeof payload === "number" || typeof payload === "bigint") {
+    return String(payload);
+  }
+  if (Array.isArray(payload)) {
+    return payload.map((value) => processPayload(value));
+  }
+  if (typeof payload === "object") {
+    const result = { ...payload };
+    if ("value" in result && result.value !== void 0) {
+      if (typeof result.value !== "string") {
+        result.value = String(result.value);
+      }
+      if (!isValidHex(result.value)) {
+        console.error(
+          "Transaction value must be a valid hex string",
+          result.value
+        );
+        throw new Error(
+          `Transaction value must be a valid hex string: ${result.value}`
+        );
+      }
+    }
+    for (const key in result) {
+      if (Object.prototype.hasOwnProperty.call(result, key)) {
+        result[key] = processPayload(result[key]);
+      }
+    }
+    return result;
+  }
+  return payload;
+};
+var validateSendTransactionPayload = (payload) => {
+  if (payload.formatPayload) {
+    const formattedPayload = processPayload(payload);
+    formattedPayload.transaction = formattedPayload.transaction.map((tx) => {
+      if ("args" in tx && tx.args !== void 0) {
+        const args = objectValuesToArrayRecursive(tx.args);
+        return {
+          ...tx,
+          args
+        };
+      }
+      return tx;
+    });
+    return formattedPayload;
+  }
+  return payload;
+};
+
+// src/commands/send-transaction/index.ts
+var WORLD_CHAIN_ID = 480;
+var WAGMI_MULTI_TX_ERROR_MESSAGE = "Wagmi fallback does not support multi-transaction execution. Pass a single transaction, run inside World App for batching, or provide a custom fallback.";
+async function sendTransaction(options, ctx) {
+  const isWagmiFallbackPath = !isInWorldApp() && hasWagmiConfig();
+  if (isWagmiFallbackPath && options.transaction.length > 1 && !options.fallback) {
+    throw new SendTransactionError("invalid_operation" /* InvalidOperation */, {
+      reason: WAGMI_MULTI_TX_ERROR_MESSAGE
+    });
+  }
+  const result = await executeWithFallback({
+    command: "send-transaction" /* SendTransaction */,
+    nativeExecutor: () => nativeSendTransaction(options, ctx),
+    wagmiFallback: () => wagmiSendTransactionAdapter(options),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  if (result.executedWith === "wagmi") {
+    return {
+      executedWith: "wagmi",
+      data: result.data
+    };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeSendTransaction(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("send-transaction" /* SendTransaction */)) {
+    throw new Error(
+      "'sendTransaction' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  if (options.chainId !== void 0 && options.chainId !== WORLD_CHAIN_ID) {
+    throw new Error(
+      `World App only supports World Chain (chainId: ${WORLD_CHAIN_ID})`
+    );
+  }
+  const input = {
+    transaction: options.transaction,
+    permit2: options.permit2,
+    formatPayload: options.formatPayload !== false
+  };
+  const validatedPayload = validateSendTransactionPayload(input);
+  const finalPayload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-send-transaction" /* MiniAppSendTransaction */, (response) => {
+          ctx.events.unsubscribe("miniapp-send-transaction" /* MiniAppSendTransaction */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "send-transaction" /* SendTransaction */,
+          version: COMMAND_VERSIONS["send-transaction" /* SendTransaction */],
+          payload: validatedPayload
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (finalPayload.status === "error") {
+    throw new SendTransactionError(
+      finalPayload.error_code,
+      finalPayload.details
+    );
+  }
+  return {
+    transactionHash: null,
+    userOpHash: finalPayload.userOpHash ?? null,
+    mini_app_id: finalPayload.mini_app_id ?? null,
+    status: finalPayload.status,
+    version: finalPayload.version,
+    transactionId: finalPayload.transaction_id,
+    reference: finalPayload.reference,
+    from: finalPayload.from,
+    chain: finalPayload.chain,
+    timestamp: finalPayload.timestamp,
+    // Deprecated aliases
+    transaction_id: finalPayload.transaction_id,
+    transaction_status: "submitted"
+  };
+}
+async function wagmiSendTransactionAdapter(options) {
+  if (options.transaction.length > 1) {
+    throw new Error(WAGMI_MULTI_TX_ERROR_MESSAGE);
+  }
+  if (options.permit2 && options.permit2.length > 0) {
+    console.warn(
+      "Permit2 signature is not automatically supported via Wagmi fallback. Transactions will execute without permit2."
+    );
+  }
+  const transactions = options.transaction.map((tx) => ({
+    address: tx.address,
+    // Encode the function call data
+    data: encodeTransactionData(tx),
+    value: tx.value
+  }));
+  const firstTransaction = transactions[0];
+  if (!firstTransaction) {
+    throw new Error("At least one transaction is required");
+  }
+  const result = await wagmiSendTransaction({
+    transaction: firstTransaction,
+    chainId: options.chainId
+  });
+  return {
+    transactionHash: result.transactionHash,
+    userOpHash: null,
+    mini_app_id: null,
+    status: "success",
+    version: 1,
+    transactionId: null,
+    reference: null,
+    from: null,
+    chain: null,
+    timestamp: null
+  };
+}
+function encodeTransactionData(tx) {
+  if (tx.data) {
+    return tx.data;
+  }
+  if (!tx.abi || !tx.functionName) {
+    throw new Error("Transaction requires `data` or `abi` + `functionName`.");
+  }
+  return (0, import_viem.encodeFunctionData)({
+    abi: tx.abi,
+    functionName: tx.functionName,
+    args: tx.args ?? []
+  });
+}
+
+// src/commands/share/format.ts
+var MAX_FILES = 10;
+var MAX_TOTAL_SIZE_MB = 50;
+var MAX_TOTAL_SIZE_BYTES = MAX_TOTAL_SIZE_MB * 1024 * 1024;
+var processFile = async (file) => {
+  const buffer = await file.arrayBuffer();
+  const uint8Array = new Uint8Array(buffer);
+  let binaryString = "";
+  const K_CHUNK_SIZE = 32768;
+  for (let i = 0; i < uint8Array.length; i += K_CHUNK_SIZE) {
+    const chunk = uint8Array.subarray(
+      i,
+      Math.min(i + K_CHUNK_SIZE, uint8Array.length)
+    );
+    binaryString += String.fromCharCode.apply(
+      null,
+      Array.from(chunk)
+      // Convert Uint8Array chunk to number[]
+    );
+  }
+  const base64Data = btoa(binaryString);
+  return {
+    name: file.name,
+    type: file.type,
+    data: base64Data
+  };
+};
+var formatShareInput = async (input) => {
+  if (!input.files) {
+    return {
+      title: input.title,
+      text: input.text,
+      url: input.url
+    };
+  }
+  if (!Array.isArray(input.files)) {
+    throw new Error('The "files" property must be an array.');
+  }
+  if (input.files.length === 0) {
+  } else {
+    if (input.files.length > MAX_FILES) {
+      throw new Error(`Cannot share more than ${MAX_FILES} files.`);
+    }
+    let totalSize = 0;
+    for (const file of input.files) {
+      if (!(file instanceof File)) {
+        throw new Error(
+          `Each item in the 'files' array must be a File object. Received: ${typeof file}`
+        );
+      }
+      totalSize += file.size;
+    }
+    if (totalSize > MAX_TOTAL_SIZE_BYTES) {
+      throw new Error(`Total file size cannot exceed ${MAX_TOTAL_SIZE_MB}MB.`);
+    }
+  }
+  const fileProcessingPromises = input.files.map((file) => processFile(file));
+  const processedFiles = await Promise.all(fileProcessingPromises);
+  return {
+    files: processedFiles,
+    title: input.title,
+    text: input.text,
+    url: input.url
+  };
+};
+
+// src/commands/share/types.ts
+var ShareError = class extends Error {
+  constructor(error_code) {
+    super(`Share failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "ShareError";
+  }
+};
+
+// src/commands/share/index.ts
+async function share(options, ctx) {
+  const result = await executeWithFallback({
+    command: "share" /* Share */,
+    nativeExecutor: () => nativeShare(options, ctx),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return {
+      executedWith: "fallback",
+      data: result.data
+    };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeShare(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("share" /* Share */)) {
+    throw new Error(
+      "'share' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payloadInput = {
+    files: options.files,
+    title: options.title,
+    text: options.text,
+    url: options.url
+  };
+  if (ctx.state.deviceProperties.deviceOS === "ios" && typeof navigator !== "undefined") {
+    sendMiniKitEvent({
+      command: "share" /* Share */,
+      version: COMMAND_VERSIONS["share" /* Share */],
+      payload: payloadInput
+    });
+    await navigator.share(payloadInput);
+    return {
+      status: "success",
+      version: COMMAND_VERSIONS["share" /* Share */],
+      shared_files_count: payloadInput.files?.length ?? 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const formattedPayload = await formatShareInput(payloadInput);
+  const payload = await new Promise((resolve, reject) => {
+    try {
+      ctx.events.subscribe("miniapp-share" /* MiniAppShare */, (response) => {
+        ctx.events.unsubscribe("miniapp-share" /* MiniAppShare */);
+        resolve(response);
+      });
+      sendMiniKitEvent({
+        command: "share" /* Share */,
+        version: COMMAND_VERSIONS["share" /* Share */],
+        payload: formattedPayload
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+  if (payload.status === "error") {
+    throw new ShareError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/share-contacts/types.ts
+var ShareContactsError = class extends Error {
+  constructor(code) {
+    super(`Share contacts failed: ${code}`);
+    this.name = "ShareContactsError";
+    this.code = code;
+  }
+};
+
+// src/commands/share-contacts/index.ts
+async function shareContacts(options, ctx) {
+  const resolvedOptions = options ?? {};
+  const result = await executeWithFallback({
+    command: "share-contacts" /* ShareContacts */,
+    nativeExecutor: () => nativeShareContacts(resolvedOptions, ctx),
+    // No Wagmi fallback - contacts is native only
+    customFallback: resolvedOptions.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return { executedWith: "minikit", data: result.data };
+}
+async function nativeShareContacts(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("share-contacts" /* ShareContacts */)) {
+    throw new Error(
+      "'shareContacts' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payload = {
+    isMultiSelectEnabled: options.isMultiSelectEnabled ?? false,
+    inviteMessage: options.inviteMessage
+  };
+  const finalPayload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-share-contacts" /* MiniAppShareContacts */, (response) => {
+          ctx.events.unsubscribe("miniapp-share-contacts" /* MiniAppShareContacts */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "share-contacts" /* ShareContacts */,
+          version: COMMAND_VERSIONS["share-contacts" /* ShareContacts */],
+          payload
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (finalPayload.status === "error") {
+    throw new ShareContactsError(finalPayload.error_code);
+  }
+  return {
+    contacts: finalPayload.contacts,
+    timestamp: finalPayload.timestamp
+  };
+}
+
+// src/commands/sign-message/types.ts
+var SignMessageError = class extends Error {
+  constructor(error_code) {
+    super(`Sign message failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "SignMessageError";
+  }
+};
+
+// src/commands/sign-message/index.ts
+async function signMessage(options, ctx) {
+  const result = await executeWithFallback({
+    command: "sign-message" /* SignMessage */,
+    nativeExecutor: () => nativeSignMessage(options, ctx),
+    wagmiFallback: () => wagmiSignMessage({
+      message: options.message
+    }),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  if (result.executedWith === "wagmi") {
+    return {
+      executedWith: "wagmi",
+      data: result.data
+    };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeSignMessage(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("sign-message" /* SignMessage */)) {
+    throw new Error(
+      "'signMessage' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-sign-message" /* MiniAppSignMessage */, (response) => {
+          ctx.events.unsubscribe("miniapp-sign-message" /* MiniAppSignMessage */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "sign-message" /* SignMessage */,
+          version: COMMAND_VERSIONS["sign-message" /* SignMessage */],
+          payload: { message: options.message }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (payload.status === "error") {
+    throw new SignMessageError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/sign-typed-data/types.ts
+var SignTypedDataError = class extends Error {
+  constructor(error_code) {
+    super(`Sign typed data failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "SignTypedDataError";
+  }
+};
+
+// src/commands/sign-typed-data/index.ts
+async function signTypedData(options, ctx) {
+  const result = await executeWithFallback({
+    command: "sign-typed-data" /* SignTypedData */,
+    nativeExecutor: () => nativeSignTypedData(options, ctx),
+    wagmiFallback: () => wagmiSignTypedData({
+      types: options.types,
+      primaryType: options.primaryType,
+      message: options.message,
+      domain: options.domain,
+      chainId: options.chainId
+    }),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  if (result.executedWith === "wagmi") {
+    return {
+      executedWith: "wagmi",
+      data: result.data
+    };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeSignTypedData(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("sign-typed-data" /* SignTypedData */)) {
+    throw new Error(
+      "'signTypedData' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const payloadInput = {
+    types: options.types,
+    primaryType: options.primaryType,
+    message: options.message,
+    domain: options.domain,
+    chainId: options.chainId ?? 480
+  };
+  const payload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-sign-typed-data" /* MiniAppSignTypedData */, (response) => {
+          ctx.events.unsubscribe("miniapp-sign-typed-data" /* MiniAppSignTypedData */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "sign-typed-data" /* SignTypedData */,
+          version: COMMAND_VERSIONS["sign-typed-data" /* SignTypedData */],
+          payload: payloadInput
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (payload.status === "error") {
+    throw new SignTypedDataError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/wallet-auth/siwe.ts
+var import_viem2 = require("viem");
+var import_chains = require("viem/chains");
+var generateSiweMessage = (siweMessageData) => {
+  let siweMessage = "";
+  if (siweMessageData.scheme) {
+    siweMessage += `${siweMessageData.scheme}://${siweMessageData.domain} wants you to sign in with your Ethereum account:
+`;
+  } else {
+    siweMessage += `${siweMessageData.domain} wants you to sign in with your Ethereum account:
+`;
+  }
+  if (siweMessageData.address) {
+    siweMessage += `${siweMessageData.address}
+`;
+  } else {
+    siweMessage += "{address}\n";
+  }
+  siweMessage += "\n";
+  if (siweMessageData.statement) {
+    siweMessage += `${siweMessageData.statement}
+`;
+  }
+  siweMessage += "\n";
+  siweMessage += `URI: ${siweMessageData.uri}
+`;
+  siweMessage += `Version: ${siweMessageData.version}
+`;
+  siweMessage += `Chain ID: ${siweMessageData.chain_id}
+`;
+  siweMessage += `Nonce: ${siweMessageData.nonce}
+`;
+  siweMessage += `Issued At: ${siweMessageData.issued_at}
+`;
+  if (siweMessageData.expiration_time) {
+    siweMessage += `Expiration Time: ${siweMessageData.expiration_time}
+`;
+  }
+  if (siweMessageData.not_before) {
+    siweMessage += `Not Before: ${siweMessageData.not_before}
+`;
+  }
+  if (siweMessageData.request_id) {
+    siweMessage += `Request ID: ${siweMessageData.request_id}
+`;
+  }
+  return siweMessage;
+};
+
+// src/commands/wallet-auth/types.ts
+var WalletAuthError = class extends Error {
+  constructor(code, details) {
+    super(details || `Wallet auth failed: ${code}`);
+    this.name = "WalletAuthError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/commands/wallet-auth/validate.ts
+var SIWE_NONCE_REGEX2 = /^[a-zA-Z0-9]+$/;
+var validateWalletAuthCommandInput = (params) => {
+  if (!params.nonce) {
+    return { valid: false, message: "'nonce' is required" };
+  }
+  if (params.nonce.length < 8) {
+    return { valid: false, message: "'nonce' must be at least 8 characters" };
+  }
+  if (!SIWE_NONCE_REGEX2.test(params.nonce)) {
+    return {
+      valid: false,
+      message: "'nonce' must be alphanumeric (letters and numbers only)"
+    };
+  }
+  if (params.statement && params.statement.includes("\n")) {
+    return { valid: false, message: "'statement' must not contain newlines" };
+  }
+  if (params.expirationTime && new Date(params.expirationTime) < /* @__PURE__ */ new Date()) {
+    return { valid: false, message: "'expirationTime' must be in the future" };
+  }
+  if (params.expirationTime && new Date(params.expirationTime) > new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3)) {
+    return { valid: false, message: "'expirationTime' must be within 7 days" };
+  }
+  if (params.notBefore && new Date(params.notBefore) > new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3)) {
+    return { valid: false, message: "'notBefore' must be within 7 days" };
+  }
+  return { valid: true };
+};
+
+// src/commands/wallet-auth/index.ts
+async function walletAuth(options, ctx) {
+  const result = await executeWithFallback({
+    command: "wallet-auth" /* WalletAuth */,
+    nativeExecutor: () => nativeWalletAuth(options, ctx),
+    wagmiFallback: () => wagmiWalletAuth({
+      nonce: options.nonce,
+      statement: options.statement,
+      expirationTime: options.expirationTime
+    }),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  if (result.executedWith === "wagmi") {
+    return {
+      executedWith: "wagmi",
+      data: result.data
+    };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeWalletAuth(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("wallet-auth" /* WalletAuth */)) {
+    throw new Error(
+      "'walletAuth' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  const input = {
+    nonce: options.nonce,
+    statement: options.statement,
+    requestId: options.requestId,
+    expirationTime: options.expirationTime,
+    notBefore: options.notBefore
+  };
+  const validationResult = validateWalletAuthCommandInput(input);
+  if (!validationResult.valid) {
+    throw new Error(`Invalid wallet auth input: ${validationResult.message}`);
+  }
+  let protocol;
+  try {
+    const currentUrl = new URL(window.location.href);
+    protocol = currentUrl.protocol.split(":")[0];
+  } catch (error) {
+    throw new Error("Failed to get current URL");
+  }
+  const siweMessage = generateSiweMessage({
+    scheme: protocol,
+    domain: window.location.host,
+    statement: input.statement ?? void 0,
+    uri: window.location.href,
+    version: "1",
+    chain_id: 480,
+    nonce: input.nonce,
+    issued_at: (/* @__PURE__ */ new Date()).toISOString(),
+    expiration_time: input.expirationTime?.toISOString() ?? void 0,
+    not_before: input.notBefore?.toISOString() ?? void 0,
+    request_id: input.requestId ?? void 0
+  });
+  const walletAuthPayload = { siweMessage };
+  const worldAppVersion = ctx.state.deviceProperties.worldAppVersion;
+  const walletAuthVersion = worldAppVersion && worldAppVersion > 2087900 ? COMMAND_VERSIONS["wallet-auth" /* WalletAuth */] : 1;
+  const finalPayload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-wallet-auth" /* MiniAppWalletAuth */, (response) => {
+          ctx.events.unsubscribe("miniapp-wallet-auth" /* MiniAppWalletAuth */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "wallet-auth" /* WalletAuth */,
+          version: walletAuthVersion,
+          payload: walletAuthPayload
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (finalPayload.status === "error") {
+    throw new WalletAuthError(finalPayload.error_code, finalPayload.details);
+  }
+  return {
+    address: finalPayload.address,
+    message: finalPayload.message,
+    signature: finalPayload.signature
+  };
+}
+
+// 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/types.ts
+var MiniKitInstallErrorMessage = {
+  ["unknown" /* Unknown */]: "Failed to install MiniKit.",
+  ["already_installed" /* AlreadyInstalled */]: "MiniKit is already installed.",
+  ["outside_of_worldapp" /* OutsideOfWorldApp */]: "MiniApp launched outside of WorldApp.",
+  ["not_on_client" /* NotOnClient */]: "Window object is not available.",
+  ["app_out_of_date" /* AppOutOfDate */]: "WorldApp is out of date. Please update the app."
+};
+
+// 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(worldApp2) {
+    if (!worldApp2) return;
+    this._user.optedIntoOptionalAnalytics = worldApp2.is_optional_analytics;
+    this._deviceProperties.safeAreaInsets = worldApp2.safe_area_insets;
+    this._deviceProperties.deviceOS = worldApp2.device_os;
+    this._deviceProperties.worldAppVersion = worldApp2.world_app_version;
+    this._location = mapWorldAppLaunchLocation(worldApp2.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__;
+}
+
+// src/connector/connector.ts
+function worldApp(options = {}) {
+  const name = options.name ?? "World App";
+  return createConnectorFn(name);
+}
+function createConnectorFn(name) {
+  return (config) => {
+    setWagmiConfig(config);
+    const provider = getWorldAppProvider();
+    return {
+      id: "worldApp",
+      name,
+      type: "worldApp",
+      async setup() {
+        const existing = MiniKit.user?.walletAddress;
+        if (existing) {
+          _setAddress(existing);
+        }
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async connect(_parameters) {
+        const accounts = await provider.request({
+          method: "eth_requestAccounts"
+        });
+        return {
+          accounts,
+          chainId: 480
+        };
+      },
+      async disconnect() {
+        _clearAddress();
+      },
+      async getAccounts() {
+        const addr = _getAddress();
+        if (addr) return [addr];
+        if (!MiniKit.isInWorldApp()) return [];
+        try {
+          const accounts = await provider.request({
+            method: "eth_requestAccounts"
+          });
+          if (Array.isArray(accounts) && accounts.length > 0 && typeof accounts[0] === "string") {
+            return [accounts[0]];
+          }
+        } catch {
+        }
+        return [];
+      },
+      async getChainId() {
+        return 480;
+      },
+      async getProvider() {
+        return provider;
+      },
+      async isAuthorized() {
+        return MiniKit.isInWorldApp() && !!_getAddress();
+      },
+      async switchChain({ chainId }) {
+        if (chainId !== 480) {
+          throw new Error("World App only supports World Chain (chainId: 480)");
+        }
+        return config.chains.find((c) => c.id === 480) ?? config.chains[0];
+      },
+      onAccountsChanged(_accounts) {
+      },
+      onChainChanged(_chainId) {
+      },
+      onDisconnect() {
+      }
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  worldApp
+});