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

package/build/minikit-provider.js

@@ -1,5 +1,12 @@
-'use client';
 "use client";
+import {
+  setWagmiConfig
+} from "./chunk-6SCI6OTQ.js";
+import {
+  MiniKit
+} from "./chunk-QOLIACKU.js";
+import "./chunk-XHYUUG6Y.js";
+import "./chunk-IYL4VCWR.js";
 
 // src/minikit-provider.tsx
 import {
@@ -8,2056 +15,18 @@ import {
   useEffect,
   useState
 } from "react";
-import * as wagmi from "wagmi";
-
-// 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
-import { encodeFunctionData } from "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 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
-import {
-  createPublicClient,
-  getContract,
-  hashMessage,
-  http,
-  recoverAddress
-} from "viem";
-import { worldchain } from "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(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/minikit-provider.tsx
 import { jsx } from "react/jsx-runtime";
 var MiniKitContext = createContext(
   void 0
 );
-function useWagmiConfigSafe() {
-  const useConfig2 = wagmi.useConfig;
-  if (!useConfig2) return void 0;
-  try {
-    return useConfig2();
-  } catch {
-    return void 0;
-  }
-}
 var MiniKitProvider = ({
   children,
   props
 }) => {
-  const detectedWagmiConfig = useWagmiConfigSafe();
   const [isInstalled, setIsInstalled] = useState(
     void 0
   );
-  const wagmiConfig = props?.wagmiConfig ?? detectedWagmiConfig;
+  const wagmiConfig = props?.wagmiConfig;
   useEffect(() => {
     const { success } = MiniKit.install(props?.appId);
     if (!success) return setIsInstalled(false);