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

package/build/index.cjs

@@ -1,7 +1,9 @@
 "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)
@@ -15,128 +17,26 @@ var __copyProps = (to, from, except, desc) => {
   }
   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);
 
-// index.ts
-var core_exports = {};
-__export(core_exports, {
-  COMMAND_VERSIONS: () => COMMAND_VERSIONS,
-  ChatErrorCodes: () => ChatErrorCodes,
-  ChatErrorMessage: () => ChatErrorMessage,
-  Command: () => Command,
-  GetPermissionsErrorCodes: () => GetPermissionsErrorCodes,
-  GetPermissionsErrorMessage: () => GetPermissionsErrorMessage,
-  MiniAppLaunchLocation: () => MiniAppLaunchLocation,
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
   MiniKit: () => MiniKit,
-  MiniKitInstallErrorCodes: () => MiniKitInstallErrorCodes,
-  MiniKitInstallErrorMessage: () => MiniKitInstallErrorMessage,
-  Network: () => Network,
-  PaymentErrorCodes: () => PaymentErrorCodes,
-  PaymentErrorMessage: () => PaymentErrorMessage,
-  Permission: () => Permission,
-  RequestPermissionErrorCodes: () => RequestPermissionErrorCodes,
-  RequestPermissionErrorMessage: () => RequestPermissionErrorMessage,
-  ResponseEvent: () => ResponseEvent,
-  SendHapticFeedbackErrorCodes: () => SendHapticFeedbackErrorCodes,
-  SendHapticFeedbackErrorMessage: () => SendHapticFeedbackErrorMessage,
-  SendTransactionErrorCodes: () => SendTransactionErrorCodes,
-  SendTransactionErrorMessage: () => SendTransactionErrorMessage,
-  ShareContactsErrorCodes: () => ShareContactsErrorCodes,
-  ShareContactsErrorMessage: () => ShareContactsErrorMessage,
-  ShareFilesErrorCodes: () => ShareFilesErrorCodes,
-  ShareFilesErrorMessage: () => ShareFilesErrorMessage,
-  SignMessageErrorCodes: () => SignMessageErrorCodes,
-  SignMessageErrorMessage: () => SignMessageErrorMessage,
-  SignTypedDataErrorCodes: () => SignTypedDataErrorCodes,
-  SignTypedDataErrorMessage: () => SignTypedDataErrorMessage,
-  TokenDecimals: () => TokenDecimals,
-  Tokens: () => Tokens,
-  VerificationErrorCodes: () => import_idkit_core2.AppErrorCodes,
-  VerificationLevel: () => import_idkit_core6.VerificationLevel,
-  WalletAuthErrorCodes: () => WalletAuthErrorCodes,
-  WalletAuthErrorMessage: () => WalletAuthErrorMessage,
-  createAsyncCommands: () => createAsyncCommands,
-  createChatAsyncCommand: () => createChatAsyncCommand,
-  createChatCommand: () => createChatCommand,
-  createCommands: () => createCommands,
-  createGetPermissionsAsyncCommand: () => createGetPermissionsAsyncCommand,
-  createGetPermissionsCommand: () => createGetPermissionsCommand,
-  createPayAsyncCommand: () => createPayAsyncCommand,
-  createPayCommand: () => createPayCommand,
-  createRequestPermissionAsyncCommand: () => createRequestPermissionAsyncCommand,
-  createRequestPermissionCommand: () => createRequestPermissionCommand,
-  createSendHapticFeedbackAsyncCommand: () => createSendHapticFeedbackAsyncCommand,
-  createSendHapticFeedbackCommand: () => createSendHapticFeedbackCommand,
-  createSendTransactionAsyncCommand: () => createSendTransactionAsyncCommand,
-  createSendTransactionCommand: () => createSendTransactionCommand,
-  createShareAsyncCommand: () => createShareAsyncCommand,
-  createShareCommand: () => createShareCommand,
-  createShareContactsAsyncCommand: () => createShareContactsAsyncCommand,
-  createShareContactsCommand: () => createShareContactsCommand,
-  createSignMessageAsyncCommand: () => createSignMessageAsyncCommand,
-  createSignMessageCommand: () => createSignMessageCommand,
-  createSignTypedDataAsyncCommand: () => createSignTypedDataAsyncCommand,
-  createSignTypedDataCommand: () => createSignTypedDataCommand,
-  createVerifyAsyncCommand: () => createVerifyAsyncCommand,
-  createVerifyCommand: () => createVerifyCommand,
-  createWalletAuthAsyncCommand: () => createWalletAuthAsyncCommand,
-  createWalletAuthCommand: () => createWalletAuthCommand,
-  getIsUserVerified: () => getIsUserVerified,
-  isCommandAvailable: () => isCommandAvailable,
-  mapWorldAppLaunchLocation: () => mapWorldAppLaunchLocation,
-  parseSiweMessage: () => parseSiweMessage,
-  sendMiniKitEvent: () => sendMiniKitEvent,
-  setCommandAvailable: () => setCommandAvailable,
-  tokenToDecimals: () => tokenToDecimals,
-  validateCommands: () => validateCommands,
-  verifyCloudProof: () => import_backend.verifyCloudProof,
-  verifySiweMessage: () => verifySiweMessage
+  getWorldAppProvider: () => getWorldAppProvider
 });
-module.exports = __toCommonJS(core_exports);
+module.exports = __toCommonJS(src_exports);
 
-// helpers/send-webview-event.ts
-var sendWebviewEvent = (payload) => {
-  if (window.webkit) {
-    window.webkit?.messageHandlers?.minikit?.postMessage?.(payload);
-  } else if (window.Android) {
-    window.Android.postMessage?.(JSON.stringify(payload));
-  }
-};
-
-// commands/types.ts
-var Command = /* @__PURE__ */ ((Command2) => {
-  Command2["Verify"] = "verify";
-  Command2["Pay"] = "pay";
-  Command2["WalletAuth"] = "wallet-auth";
-  Command2["SendTransaction"] = "send-transaction";
-  Command2["SignMessage"] = "sign-message";
-  Command2["SignTypedData"] = "sign-typed-data";
-  Command2["ShareContacts"] = "share-contacts";
-  Command2["RequestPermission"] = "request-permission";
-  Command2["GetPermissions"] = "get-permissions";
-  Command2["SendHapticFeedback"] = "send-haptic-feedback";
-  Command2["Share"] = "share";
-  Command2["Chat"] = "chat";
-  return Command2;
-})(Command || {});
-var ResponseEvent = /* @__PURE__ */ ((ResponseEvent3) => {
-  ResponseEvent3["MiniAppVerifyAction"] = "miniapp-verify-action";
-  ResponseEvent3["MiniAppPayment"] = "miniapp-payment";
-  ResponseEvent3["MiniAppWalletAuth"] = "miniapp-wallet-auth";
-  ResponseEvent3["MiniAppSendTransaction"] = "miniapp-send-transaction";
-  ResponseEvent3["MiniAppSignMessage"] = "miniapp-sign-message";
-  ResponseEvent3["MiniAppSignTypedData"] = "miniapp-sign-typed-data";
-  ResponseEvent3["MiniAppShareContacts"] = "miniapp-share-contacts";
-  ResponseEvent3["MiniAppRequestPermission"] = "miniapp-request-permission";
-  ResponseEvent3["MiniAppGetPermissions"] = "miniapp-get-permissions";
-  ResponseEvent3["MiniAppSendHapticFeedback"] = "miniapp-send-haptic-feedback";
-  ResponseEvent3["MiniAppShare"] = "miniapp-share";
-  ResponseEvent3["MiniAppMicrophone"] = "miniapp-microphone";
-  ResponseEvent3["MiniAppChat"] = "miniapp-chat";
-  return ResponseEvent3;
-})(ResponseEvent || {});
+// src/commands/types.ts
 var COMMAND_VERSIONS = {
-  ["verify" /* Verify */]: 1,
   ["pay" /* Pay */]: 1,
   ["wallet-auth" /* WalletAuth */]: 2,
   ["send-transaction" /* SendTransaction */]: 1,
@@ -150,7 +50,6 @@ var COMMAND_VERSIONS = {
   ["chat" /* Chat */]: 1
 };
 var commandAvailability = {
-  ["verify" /* Verify */]: false,
   ["pay" /* Pay */]: false,
   ["wallet-auth" /* WalletAuth */]: false,
   ["send-transaction" /* SendTransaction */]: false,
@@ -164,7 +63,7 @@ var commandAvailability = {
   ["chat" /* Chat */]: false
 };
 function isCommandAvailable(command) {
-  return commandAvailability[command];
+  return commandAvailability[command] ?? false;
 }
 function setCommandAvailable(command, available) {
   commandAvailability[command] = available;
@@ -199,141 +98,447 @@ function validateCommands(worldAppSupportedCommands) {
   return allCommandsValid;
 }
 function sendMiniKitEvent(payload) {
-  sendWebviewEvent(payload);
+  if (window.webkit) {
+    window.webkit?.messageHandlers?.minikit?.postMessage?.(payload);
+  } else if (window.Android) {
+    window.Android?.postMessage?.(JSON.stringify(payload));
+  }
 }
-
-// commands/chat.ts
-var ChatErrorCodes = /* @__PURE__ */ ((ChatErrorCodes2) => {
-  ChatErrorCodes2["UserRejected"] = "user_rejected";
-  ChatErrorCodes2["SendFailed"] = "send_failed";
-  ChatErrorCodes2["GenericError"] = "generic_error";
-  return ChatErrorCodes2;
-})(ChatErrorCodes || {});
-var ChatErrorMessage = {
-  ["user_rejected" /* UserRejected */]: "User rejected the request.",
-  ["send_failed" /* SendFailed */]: "Failed to send the message.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong."
+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;
+  }
 };
-function createChatCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("chat" /* Chat */)) {
+
+// 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(
-        "'chat' command is unavailable. Check MiniKit.install() or update the app version"
+        `No handler for event ${event}, payload: ${JSON.stringify(payload)}`
       );
-      return null;
+      return;
     }
-    if (payload.message.length === 0) {
-      console.error("'chat' command requires a non-empty message");
-      return null;
+    this.listeners[event](payload);
+  }
+};
+
+// src/commands/wagmi-fallback.ts
+var SIWE_NONCE_REGEX = /^[a-zA-Z0-9]{8,}$/;
+var WAGMI_KEY = "__minikit_wagmi_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;
+      }
     }
-    sendMiniKitEvent({
-      command: "chat" /* Chat */,
-      version: COMMAND_VERSIONS["chat" /* Chat */],
-      payload
-    });
-    return payload;
+  } 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
   };
 }
-function createChatAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
-      try {
-        let commandPayload = null;
-        const handleResponse = (response) => {
-          ctx.events.unsubscribe("miniapp-chat" /* MiniAppChat */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe("miniapp-chat" /* MiniAppChat */, handleResponse);
-        commandPayload = syncCommand(payload);
-      } catch (error) {
-        reject(error);
-      }
-    });
+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
   };
 }
-
-// commands/get-permissions.ts
-var GetPermissionsErrorCodes = /* @__PURE__ */ ((GetPermissionsErrorCodes2) => {
-  GetPermissionsErrorCodes2["GenericError"] = "generic_error";
-  return GetPermissionsErrorCodes2;
-})(GetPermissionsErrorCodes || {});
-var GetPermissionsErrorMessage = {
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again."
-};
-var Permission = /* @__PURE__ */ ((Permission2) => {
-  Permission2["Notifications"] = "notifications";
-  Permission2["Contacts"] = "contacts";
-  Permission2["Microphone"] = "microphone";
-  return Permission2;
-})(Permission || {});
-function createGetPermissionsCommand(_ctx) {
-  return () => {
-    if (typeof window === "undefined" || !isCommandAvailable("get-permissions" /* GetPermissions */)) {
-      console.error(
-        "'getPermissions' command is unavailable. Check MiniKit.install() or update the app version"
+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.`
       );
-      return null;
     }
-    sendMiniKitEvent({
-      command: "get-permissions" /* GetPermissions */,
-      version: COMMAND_VERSIONS["get-permissions" /* GetPermissions */],
-      payload: {}
+  };
+  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
     });
-    return {
-      status: "sent"
-    };
+  } 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/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
   };
 }
-function createGetPermissionsAsyncCommand(ctx, syncCommand) {
-  return async () => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (payload) => {
+        ctx.events.subscribe("miniapp-get-permissions" /* MiniAppGetPermissions */, (response) => {
           ctx.events.unsubscribe("miniapp-get-permissions" /* MiniAppGetPermissions */);
-          resolve({ commandPayload, finalPayload: payload });
-        };
-        ctx.events.subscribe(
-          "miniapp-get-permissions" /* MiniAppGetPermissions */,
-          handleResponse
-        );
-        commandPayload = syncCommand();
+          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;
 }
 
-// types/payment.ts
-var Tokens = /* @__PURE__ */ ((Tokens3) => {
-  Tokens3["USDC"] = "USDCE";
-  Tokens3["WLD"] = "WLD";
-  return Tokens3;
-})(Tokens || {});
-var TokenDecimals = {
-  ["USDCE" /* USDC */]: 6,
-  ["WLD" /* WLD */]: 18
+// src/commands/pay/types.ts
+var PayError = class extends Error {
+  constructor(code) {
+    super(`Payment failed: ${code}`);
+    this.name = "PayError";
+    this.code = code;
+  }
 };
-var Network = /* @__PURE__ */ ((Network2) => {
-  Network2["Optimism"] = "optimism";
-  Network2["WorldChain"] = "worldchain";
-  return Network2;
-})(Network || {});
 
-// helpers/payment/client.ts
-var tokenToDecimals = (amount, token) => {
-  const decimals = TokenDecimals[token];
-  if (decimals === void 0) {
-    throw new Error(`Invalid token: ${token}`);
-  }
-  const factor = 10 ** decimals;
-  const result = amount * factor;
-  if (!Number.isInteger(result)) {
-    throw new Error(`The resulting amount is not a whole number: ${result}`);
-  }
-  return result;
-};
+// src/commands/pay/validate.ts
 var validatePaymentPayload = (payload) => {
   if (payload.tokens.some(
     (token) => token.symbol == "USDCE" /* USDC */ && parseFloat(token.token_amount) < 0.1
@@ -351,175 +556,204 @@ var validatePaymentPayload = (payload) => {
   return true;
 };
 
-// commands/pay.ts
-var PaymentErrorCodes = /* @__PURE__ */ ((PaymentErrorCodes2) => {
-  PaymentErrorCodes2["InputError"] = "input_error";
-  PaymentErrorCodes2["UserRejected"] = "user_rejected";
-  PaymentErrorCodes2["PaymentRejected"] = "payment_rejected";
-  PaymentErrorCodes2["InvalidReceiver"] = "invalid_receiver";
-  PaymentErrorCodes2["InsufficientBalance"] = "insufficient_balance";
-  PaymentErrorCodes2["TransactionFailed"] = "transaction_failed";
-  PaymentErrorCodes2["GenericError"] = "generic_error";
-  PaymentErrorCodes2["UserBlocked"] = "user_blocked";
-  return PaymentErrorCodes2;
-})(PaymentErrorCodes || {});
-var PaymentErrorMessage = {
-  ["input_error" /* InputError */]: "There was a problem with this request. Please try again or contact the app owner.",
-  ["user_rejected" /* UserRejected */]: "You have cancelled the payment in World App.",
-  ["payment_rejected" /* PaymentRejected */]: "You've cancelled the payment in World App.",
-  ["invalid_receiver" /* InvalidReceiver */]: "The receiver address is invalid. Please contact the app owner.",
-  ["insufficient_balance" /* InsufficientBalance */]: "You do not have enough balance to complete this transaction.",
-  ["transaction_failed" /* TransactionFailed */]: "The transaction failed. Please try again.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again.",
-  ["user_blocked" /* UserBlocked */]: "User's region is blocked from making payments."
-};
-function createPayCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("pay" /* Pay */)) {
-      console.error(
-        "'pay' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    if (!validatePaymentPayload(payload)) {
-      return null;
-    }
-    const eventPayload = {
-      ...payload,
-      network: "worldchain" /* WorldChain */
-    };
-    sendMiniKitEvent({
-      command: "pay" /* Pay */,
-      version: COMMAND_VERSIONS["pay" /* Pay */],
-      payload: eventPayload
-    });
-    return eventPayload;
-  };
+// 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 };
 }
-function createPayAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (response) => {
+        ctx.events.subscribe("miniapp-payment" /* MiniAppPayment */, (response) => {
           ctx.events.unsubscribe("miniapp-payment" /* MiniAppPayment */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-payment" /* MiniAppPayment */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
+          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
   };
 }
 
-// commands/request-permission.ts
-var RequestPermissionErrorCodes = /* @__PURE__ */ ((RequestPermissionErrorCodes2) => {
-  RequestPermissionErrorCodes2["UserRejected"] = "user_rejected";
-  RequestPermissionErrorCodes2["GenericError"] = "generic_error";
-  RequestPermissionErrorCodes2["AlreadyRequested"] = "already_requested";
-  RequestPermissionErrorCodes2["PermissionDisabled"] = "permission_disabled";
-  RequestPermissionErrorCodes2["AlreadyGranted"] = "already_granted";
-  RequestPermissionErrorCodes2["UnsupportedPermission"] = "unsupported_permission";
-  return RequestPermissionErrorCodes2;
-})(RequestPermissionErrorCodes || {});
-var RequestPermissionErrorMessage = {
-  ["user_rejected" /* UserRejected */]: "User declined sharing contacts",
-  ["generic_error" /* GenericError */]: "Request failed for unknown reason.",
-  ["already_requested" /* AlreadyRequested */]: "User has already declined turning on notifications once",
-  ["permission_disabled" /* PermissionDisabled */]: "User does not have this permission enabled in World App",
-  ["already_granted" /* AlreadyGranted */]: "If the user has already granted this mini app permission",
-  ["unsupported_permission" /* UnsupportedPermission */]: "The permission requested is not supported by this mini app"
+// 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";
+  }
 };
-function createRequestPermissionCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("request-permission" /* RequestPermission */)) {
-      console.error(
-        "'requestPermission' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    sendMiniKitEvent({
-      command: "request-permission" /* RequestPermission */,
-      version: COMMAND_VERSIONS["request-permission" /* RequestPermission */],
-      payload
-    });
-    return payload;
+
+// 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
   };
 }
-function createRequestPermissionAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (response) => {
+        ctx.events.subscribe("miniapp-request-permission" /* MiniAppRequestPermission */, (response) => {
           ctx.events.unsubscribe("miniapp-request-permission" /* MiniAppRequestPermission */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-request-permission" /* MiniAppRequestPermission */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
+          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;
 }
 
-// commands/send-haptic-feedback.ts
-var SendHapticFeedbackErrorCodes = /* @__PURE__ */ ((SendHapticFeedbackErrorCodes2) => {
-  SendHapticFeedbackErrorCodes2["GenericError"] = "generic_error";
-  SendHapticFeedbackErrorCodes2["UserRejected"] = "user_rejected";
-  return SendHapticFeedbackErrorCodes2;
-})(SendHapticFeedbackErrorCodes || {});
-var SendHapticFeedbackErrorMessage = {
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong.",
-  ["user_rejected" /* UserRejected */]: "User rejected the request."
+// 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";
+  }
 };
-function createSendHapticFeedbackCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("send-haptic-feedback" /* SendHapticFeedback */)) {
-      console.error(
-        "'sendHapticFeedback' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    sendMiniKitEvent({
-      command: "send-haptic-feedback" /* SendHapticFeedback */,
-      version: COMMAND_VERSIONS["send-haptic-feedback" /* SendHapticFeedback */],
-      payload
-    });
-    return payload;
-  };
-}
-function createSendHapticFeedbackAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
-      try {
-        let commandPayload = null;
-        const handleResponse = (response) => {
+
+// 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({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-send-haptic-feedback" /* MiniAppSendHapticFeedback */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
+          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;
 }
 
-// helpers/transaction/validate-payload.ts
+// 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);
 };
@@ -572,89 +806,160 @@ var validateSendTransactionPayload = (payload) => {
   if (payload.formatPayload) {
     const formattedPayload = processPayload(payload);
     formattedPayload.transaction = formattedPayload.transaction.map((tx) => {
-      const args = objectValuesToArrayRecursive(tx.args);
-      return {
-        ...tx,
-        args
-      };
+      if ("args" in tx && tx.args !== void 0) {
+        const args = objectValuesToArrayRecursive(tx.args);
+        return {
+          ...tx,
+          args
+        };
+      }
+      return tx;
     });
     return formattedPayload;
   }
   return payload;
 };
 
-// commands/send-transaction.ts
-var SendTransactionErrorCodes = /* @__PURE__ */ ((SendTransactionErrorCodes2) => {
-  SendTransactionErrorCodes2["InvalidOperation"] = "invalid_operation";
-  SendTransactionErrorCodes2["UserRejected"] = "user_rejected";
-  SendTransactionErrorCodes2["InputError"] = "input_error";
-  SendTransactionErrorCodes2["SimulationFailed"] = "simulation_failed";
-  SendTransactionErrorCodes2["TransactionFailed"] = "transaction_failed";
-  SendTransactionErrorCodes2["GenericError"] = "generic_error";
-  SendTransactionErrorCodes2["DisallowedOperation"] = "disallowed_operation";
-  SendTransactionErrorCodes2["ValidationError"] = "validation_error";
-  SendTransactionErrorCodes2["InvalidContract"] = "invalid_contract";
-  SendTransactionErrorCodes2["MaliciousOperation"] = "malicious_operation";
-  SendTransactionErrorCodes2["DailyTxLimitReached"] = "daily_tx_limit_reached";
-  SendTransactionErrorCodes2["PermittedAmountExceedsSlippage"] = "permitted_amount_exceeds_slippage";
-  SendTransactionErrorCodes2["PermittedAmountNotFound"] = "permitted_amount_not_found";
-  return SendTransactionErrorCodes2;
-})(SendTransactionErrorCodes || {});
-var SendTransactionErrorMessage = {
-  ["invalid_operation" /* InvalidOperation */]: "Transaction included an operation that was invalid",
-  ["user_rejected" /* UserRejected */]: "User rejected the request.",
-  ["input_error" /* InputError */]: "Invalid payload.",
-  ["simulation_failed" /* SimulationFailed */]: "The transaction simulation failed.",
-  ["validation_error" /* ValidationError */]: "The transaction validation failed. Please try again.",
-  ["transaction_failed" /* TransactionFailed */]: "The transaction failed. Please try again later.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again.",
-  ["disallowed_operation" /* DisallowedOperation */]: "The operation requested is not allowed. Please refer to the docs.",
-  ["invalid_contract" /* InvalidContract */]: "The contract address is not allowed for your application. Please check your developer portal configurations",
-  ["malicious_operation" /* MaliciousOperation */]: "The operation requested is considered malicious.",
-  ["daily_tx_limit_reached" /* DailyTxLimitReached */]: "Daily transaction limit reached. Max 100 transactions per day. Wait until the next day.",
-  ["permitted_amount_exceeds_slippage" /* PermittedAmountExceedsSlippage */]: "Permitted amount exceeds slippage. You must spend at least 90% of the permitted amount.",
-  ["permitted_amount_not_found" /* PermittedAmountNotFound */]: "Permitted amount not found in permit2 payload."
-};
-function createSendTransactionCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("send-transaction" /* SendTransaction */)) {
-      console.error(
-        "'sendTransaction' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    payload.formatPayload = payload.formatPayload !== false;
-    const validatedPayload = validateSendTransactionPayload(payload);
-    sendMiniKitEvent({
-      command: "send-transaction" /* SendTransaction */,
-      version: COMMAND_VERSIONS["send-transaction" /* SendTransaction */],
-      payload: validatedPayload
+// 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
     });
-    return validatedPayload;
+  }
+  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
   };
 }
-function createSendTransactionAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (response) => {
+        ctx.events.subscribe("miniapp-send-transaction" /* MiniAppSendTransaction */, (response) => {
           ctx.events.unsubscribe("miniapp-send-transaction" /* MiniAppSendTransaction */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-send-transaction" /* MiniAppSendTransaction */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
+          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 ?? []
+  });
+}
 
-// helpers/share/index.ts
+// 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;
@@ -720,388 +1025,290 @@ var formatShareInput = async (input) => {
   };
 };
 
-// commands/share.ts
-var ShareFilesErrorCodes = /* @__PURE__ */ ((ShareFilesErrorCodes2) => {
-  ShareFilesErrorCodes2["UserRejected"] = "user_rejected";
-  ShareFilesErrorCodes2["GenericError"] = "generic_error";
-  ShareFilesErrorCodes2["InvalidFileName"] = "invalid_file_name";
-  return ShareFilesErrorCodes2;
-})(ShareFilesErrorCodes || {});
-var ShareFilesErrorMessage = {
-  ["user_rejected" /* UserRejected */]: "User rejected the request.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong.",
-  ["invalid_file_name" /* InvalidFileName */]: "Invalid file name. Make sure you include the extension"
+// 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";
+  }
 };
-function createShareCommand(ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("share" /* Share */)) {
-      console.error(
-        "'share' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    if (ctx.state.deviceProperties.deviceOS === "ios" && typeof navigator !== "undefined") {
+
+// 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
-      });
-      navigator.share(payload);
-    } else {
-      formatShareInput(payload).then((formattedResult) => {
-        sendMiniKitEvent({
-          command: "share" /* Share */,
-          version: COMMAND_VERSIONS["share" /* Share */],
-          payload: formattedResult
-        });
-      }).catch((error) => {
-        console.error("Failed to format share input", error);
-      });
-      ctx.events.subscribe("miniapp-share" /* MiniAppShare */, (response) => {
-        console.log("Share Response", response);
+        payload: formattedPayload
       });
+    } catch (error) {
+      reject(error);
     }
-    return payload;
-  };
-}
-function createShareAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
-      try {
-        let commandPayload = null;
-        const handleResponse = (response) => {
-          ctx.events.unsubscribe("miniapp-share" /* MiniAppShare */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe("miniapp-share" /* MiniAppShare */, handleResponse);
-        commandPayload = syncCommand(payload);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
+  });
+  if (payload.status === "error") {
+    throw new ShareError(payload.error_code);
+  }
+  return payload;
 }
 
-// commands/share-contacts.ts
-var ShareContactsErrorCodes = /* @__PURE__ */ ((ShareContactsErrorCodes2) => {
-  ShareContactsErrorCodes2["UserRejected"] = "user_rejected";
-  ShareContactsErrorCodes2["GenericError"] = "generic_error";
-  return ShareContactsErrorCodes2;
-})(ShareContactsErrorCodes || {});
-var ShareContactsErrorMessage = {
-  ["user_rejected" /* UserRejected */]: "User rejected the request.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong."
+// src/commands/share-contacts/types.ts
+var ShareContactsError = class extends Error {
+  constructor(code) {
+    super(`Share contacts failed: ${code}`);
+    this.name = "ShareContactsError";
+    this.code = code;
+  }
 };
-function createShareContactsCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("share-contacts" /* ShareContacts */)) {
-      console.error(
-        "'shareContacts' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    sendMiniKitEvent({
-      command: "share-contacts" /* ShareContacts */,
-      version: COMMAND_VERSIONS["share-contacts" /* ShareContacts */],
-      payload
-    });
-    return payload;
-  };
+
+// 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 };
 }
-function createShareContactsAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (response) => {
+        ctx.events.subscribe("miniapp-share-contacts" /* MiniAppShareContacts */, (response) => {
           ctx.events.unsubscribe("miniapp-share-contacts" /* MiniAppShareContacts */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-share-contacts" /* MiniAppShareContacts */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
+          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
   };
 }
 
-// commands/sign-message.ts
-var SignMessageErrorCodes = /* @__PURE__ */ ((SignMessageErrorCodes2) => {
-  SignMessageErrorCodes2["InvalidMessage"] = "invalid_message";
-  SignMessageErrorCodes2["UserRejected"] = "user_rejected";
-  SignMessageErrorCodes2["GenericError"] = "generic_error";
-  return SignMessageErrorCodes2;
-})(SignMessageErrorCodes || {});
-var SignMessageErrorMessage = {
-  ["invalid_message" /* InvalidMessage */]: "Invalid message requested",
-  ["user_rejected" /* UserRejected */]: "User rejected the request.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong."
+// 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";
+  }
 };
-function createSignMessageCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("sign-message" /* SignMessage */)) {
-      console.error(
-        "'signMessage' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    sendMiniKitEvent({
-      command: "sign-message" /* SignMessage */,
-      version: COMMAND_VERSIONS["sign-message" /* SignMessage */],
-      payload
-    });
-    return payload;
+
+// 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
   };
 }
-function createSignMessageAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (response) => {
+        ctx.events.subscribe("miniapp-sign-message" /* MiniAppSignMessage */, (response) => {
           ctx.events.unsubscribe("miniapp-sign-message" /* MiniAppSignMessage */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-sign-message" /* MiniAppSignMessage */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
+          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;
 }
 
-// commands/sign-typed-data.ts
-var SignTypedDataErrorCodes = /* @__PURE__ */ ((SignTypedDataErrorCodes2) => {
-  SignTypedDataErrorCodes2["InvalidOperation"] = "invalid_operation";
-  SignTypedDataErrorCodes2["UserRejected"] = "user_rejected";
-  SignTypedDataErrorCodes2["InputError"] = "input_error";
-  SignTypedDataErrorCodes2["SimulationFailed"] = "simulation_failed";
-  SignTypedDataErrorCodes2["GenericError"] = "generic_error";
-  SignTypedDataErrorCodes2["DisallowedOperation"] = "disallowed_operation";
-  SignTypedDataErrorCodes2["InvalidContract"] = "invalid_contract";
-  SignTypedDataErrorCodes2["MaliciousOperation"] = "malicious_operation";
-  return SignTypedDataErrorCodes2;
-})(SignTypedDataErrorCodes || {});
-var SignTypedDataErrorMessage = {
-  ["invalid_operation" /* InvalidOperation */]: "Transaction included an operation that was invalid",
-  ["user_rejected" /* UserRejected */]: "User rejected the request.",
-  ["input_error" /* InputError */]: "Invalid payload.",
-  ["simulation_failed" /* SimulationFailed */]: "The transaction simulation failed.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again.",
-  ["disallowed_operation" /* DisallowedOperation */]: "The operation requested is not allowed. Please refer to the docs.",
-  ["invalid_contract" /* InvalidContract */]: "The contract address is not allowed for your application. Please check your developer portal configurations",
-  ["malicious_operation" /* MaliciousOperation */]: "The operation requested is considered malicious."
+// 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";
+  }
 };
-function createSignTypedDataCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("sign-typed-data" /* SignTypedData */)) {
-      console.error(
-        "'signTypedData' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    if (!payload.chainId) {
-      payload.chainId = 480;
-    }
-    sendMiniKitEvent({
-      command: "sign-typed-data" /* SignTypedData */,
-      version: COMMAND_VERSIONS["sign-typed-data" /* SignTypedData */],
-      payload
-    });
-    return payload;
-  };
-}
-function createSignTypedDataAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
-      try {
-        let commandPayload = null;
-        const handleResponse = (response) => {
-          ctx.events.unsubscribe("miniapp-sign-typed-data" /* MiniAppSignTypedData */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-sign-typed-data" /* MiniAppSignTypedData */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
-}
 
-// commands/verify.ts
-var import_idkit_core = require("@worldcoin/idkit-core");
-var import_hashing = require("@worldcoin/idkit-core/hashing");
-var import_idkit_core2 = require("@worldcoin/idkit-core");
-function createVerifyCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("verify" /* Verify */)) {
-      console.error(
-        "'verify' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    if (Array.isArray(payload.verification_level) && payload.verification_level.length === 0) {
-      console.error("'verification_level' must not be an empty array");
-      return null;
-    }
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const eventPayload = {
-      action: (0, import_hashing.encodeAction)(payload.action),
-      signal: (0, import_hashing.generateSignal)(payload.signal).digest,
-      verification_level: payload.verification_level || import_idkit_core.VerificationLevel.Orb,
-      timestamp
+// 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
     };
-    sendMiniKitEvent({
-      command: "verify" /* Verify */,
-      version: COMMAND_VERSIONS["verify" /* Verify */],
-      payload: eventPayload
-    });
-    return eventPayload;
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
   };
 }
-function createVerifyAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (response) => {
-          ctx.events.unsubscribe("miniapp-verify-action" /* MiniAppVerifyAction */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-verify-action" /* MiniAppVerifyAction */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
+        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;
 }
 
-// helpers/siwe/siwe.ts
-var import_viem = require("viem");
+// src/commands/wallet-auth/siwe.ts
+var import_viem2 = require("viem");
 var import_chains = require("viem/chains");
-var PREAMBLE = " wants you to sign in with your Ethereum account:";
-var URI_TAG = "URI: ";
-var VERSION_TAG = "Version: ";
-var CHAIN_TAG = "Chain ID: ";
-var NONCE_TAG = "Nonce: ";
-var IAT_TAG = "Issued At: ";
-var EXP_TAG = "Expiration Time: ";
-var NBF_TAG = "Not Before: ";
-var RID_TAG = "Request ID: ";
-var ERC_191_PREFIX = "Ethereum Signed Message:\n";
-var EIP1271_MAGICVALUE = "0x1626ba7e";
-var SAFE_CONTRACT_ABI = [
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "owner",
-        type: "address"
-      }
-    ],
-    name: "isOwner",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "_message",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes",
-        name: "_signature",
-        type: "bytes"
-      }
-    ],
-    name: "isValidSignature",
-    outputs: [
-      {
-        internalType: "bytes4",
-        name: "",
-        type: "bytes4"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var tagged = (line, tag) => {
-  if (line && line.includes(tag)) {
-    return line.replace(tag, "");
-  } else {
-    throw new Error(`Missing '${tag}'`);
-  }
-};
-var parseSiweMessage = (inputString) => {
-  const lines = inputString.split("\n")[Symbol.iterator]();
-  const domain = tagged(lines.next()?.value, PREAMBLE);
-  const address = lines.next()?.value;
-  lines.next();
-  const nextValue = lines.next()?.value;
-  let statement;
-  if (nextValue) {
-    statement = nextValue;
-    lines.next();
-  }
-  const uri = tagged(lines.next()?.value, URI_TAG);
-  const version = tagged(lines.next()?.value, VERSION_TAG);
-  const chain_id = tagged(lines.next()?.value, CHAIN_TAG);
-  const nonce = tagged(lines.next()?.value, NONCE_TAG);
-  const issued_at = tagged(lines.next()?.value, IAT_TAG);
-  let expiration_time, not_before, request_id;
-  for (let line of lines) {
-    if (line.startsWith(EXP_TAG)) {
-      expiration_time = tagged(line, EXP_TAG);
-    } else if (line.startsWith(NBF_TAG)) {
-      not_before = tagged(line, NBF_TAG);
-    } else if (line.startsWith(RID_TAG)) {
-      request_id = tagged(line, RID_TAG);
-    }
-  }
-  if (lines.next().done === false) {
-    throw new Error("Extra lines in the input");
-  }
-  const siweMessageData = {
-    domain,
-    address,
-    statement,
-    uri,
-    version,
-    chain_id,
-    nonce,
-    issued_at,
-    expiration_time,
-    not_before,
-    request_id
-  };
-  return siweMessageData;
-};
 var generateSiweMessage = (siweMessageData) => {
   let siweMessage = "";
   if (siweMessageData.scheme) {
@@ -1141,561 +1348,150 @@ var generateSiweMessage = (siweMessageData) => {
     siweMessage += `Not Before: ${siweMessageData.not_before}
 `;
   }
-  if (siweMessageData.request_id) {
-    siweMessage += `Request ID: ${siweMessageData.request_id}
-`;
-  }
-  return siweMessage;
-};
-var verifySiweMessage = (payload, nonce, statement, requestId, userProvider) => {
-  if (payload.version === 1) {
-    return verifySiweMessageV1(
-      payload,
-      nonce,
-      statement,
-      requestId,
-      userProvider
-    );
-  } else {
-    return verifySiweMessageV2(
-      payload,
-      nonce,
-      statement,
-      requestId,
-      userProvider
-    );
-  }
-};
-var validateMessage = (siweMessageData, nonce, statement, requestId) => {
-  if (siweMessageData.expiration_time) {
-    const expirationTime = new Date(siweMessageData.expiration_time);
-    if (expirationTime < /* @__PURE__ */ new Date()) {
-      throw new Error("Expired message");
-    }
-  }
-  if (siweMessageData.not_before) {
-    const notBefore = new Date(siweMessageData.not_before);
-    if (notBefore > /* @__PURE__ */ new Date()) {
-      throw new Error("Not Before time has not passed");
-    }
-  }
-  if (nonce && siweMessageData.nonce !== nonce) {
-    throw new Error(
-      `Nonce mismatch. Got: ${siweMessageData.nonce}, Expected: ${nonce}`
-    );
-  }
-  if (statement && siweMessageData.statement !== statement) {
-    throw new Error(
-      `Statement mismatch. Got: ${siweMessageData.statement}, Expected: ${statement}`
-    );
-  }
-  if (requestId && siweMessageData.request_id !== requestId) {
-    throw new Error(
-      `Request ID mismatch. Got: ${siweMessageData.request_id}, Expected: ${requestId}`
-    );
-  }
-  return true;
-};
-var verifySiweMessageV1 = async (payload, nonce, statement, requestId, userProvider) => {
-  if (typeof window !== "undefined") {
-    throw new Error("Wallet auth payload can only be verified in the backend");
-  }
-  const { message, signature, address } = payload;
-  const siweMessageData = parseSiweMessage(message);
-  validateMessage(siweMessageData, nonce, statement, requestId);
-  let provider = userProvider || (0, import_viem.createPublicClient)({ chain: import_chains.worldchain, transport: (0, import_viem.http)() });
-  const signedMessage = `${ERC_191_PREFIX}${message.length}${message}`;
-  const hashedMessage = (0, import_viem.hashMessage)(signedMessage);
-  const contract = (0, import_viem.getContract)({
-    address,
-    abi: SAFE_CONTRACT_ABI,
-    client: provider
-  });
-  try {
-    const recoveredAddress = await (0, import_viem.recoverAddress)({
-      hash: hashedMessage,
-      signature: `0x${signature}`
-    });
-    const isOwner = await contract.read.isOwner([recoveredAddress]);
-    if (!isOwner) {
-      throw new Error("Signature verification failed, invalid owner");
-    }
-  } catch (error) {
-    throw new Error("Signature verification failed");
-  }
-  return { isValid: true, siweMessageData };
-};
-var verifySiweMessageV2 = async (payload, nonce, statement, requestId, userProvider) => {
-  if (typeof window !== "undefined") {
-    throw new Error("Wallet auth payload can only be verified in the backend");
-  }
-  const { message, signature, address } = payload;
-  const siweMessageData = parseSiweMessage(message);
-  if (!validateMessage(siweMessageData, nonce, statement, requestId)) {
-    throw new Error("Validation failed");
-  }
-  try {
-    const walletContract = (0, import_viem.getContract)({
-      address,
-      abi: SAFE_CONTRACT_ABI,
-      client: userProvider || (0, import_viem.createPublicClient)({ chain: import_chains.worldchain, transport: (0, import_viem.http)() })
-    });
-    const hashedMessage = (0, import_viem.hashMessage)(message);
-    const res = await walletContract.read.isValidSignature([
-      hashedMessage,
-      signature
-    ]);
-    return {
-      isValid: res === EIP1271_MAGICVALUE,
-      siweMessageData
-    };
-  } catch (error) {
-    console.log(error);
-    throw new Error("Signature verification failed");
-  }
-};
-
-// helpers/siwe/validate-wallet-auth-command-input.ts
-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 (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 };
-};
-
-// commands/wallet-auth.ts
-var WalletAuthErrorCodes = /* @__PURE__ */ ((WalletAuthErrorCodes2) => {
-  WalletAuthErrorCodes2["MalformedRequest"] = "malformed_request";
-  WalletAuthErrorCodes2["UserRejected"] = "user_rejected";
-  WalletAuthErrorCodes2["GenericError"] = "generic_error";
-  return WalletAuthErrorCodes2;
-})(WalletAuthErrorCodes || {});
-var WalletAuthErrorMessage = {
-  ["malformed_request" /* MalformedRequest */]: "Provided parameters in the request are invalid.",
-  ["user_rejected" /* UserRejected */]: "User rejected the request.",
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong."
-};
-function createWalletAuthCommand(ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("wallet-auth" /* WalletAuth */)) {
-      console.error(
-        "'walletAuth' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    const validationResult = validateWalletAuthCommandInput(payload);
-    if (!validationResult.valid) {
-      console.error(
-        "Failed to validate wallet auth input:\n\n -->",
-        validationResult.message
-      );
-      return null;
-    }
-    let protocol = null;
-    try {
-      const currentUrl = new URL(window.location.href);
-      protocol = currentUrl.protocol.split(":")[0];
-    } catch (error) {
-      console.error("Failed to get current URL", error);
-      return null;
-    }
-    const siweMessage = generateSiweMessage({
-      scheme: protocol,
-      domain: window.location.host,
-      statement: payload.statement ?? void 0,
-      uri: window.location.href,
-      version: "1",
-      chain_id: 480,
-      nonce: payload.nonce,
-      issued_at: (/* @__PURE__ */ new Date()).toISOString(),
-      expiration_time: payload.expirationTime?.toISOString() ?? void 0,
-      not_before: payload.notBefore?.toISOString() ?? void 0,
-      request_id: payload.requestId ?? void 0
-    });
-    const walletAuthPayload = { siweMessage };
-    const walletAuthVersion = ctx.state.user.worldAppVersion && ctx.state.user.worldAppVersion > 2087900 ? COMMAND_VERSIONS["wallet-auth" /* WalletAuth */] : 1;
-    sendMiniKitEvent({
-      command: "wallet-auth" /* WalletAuth */,
-      version: walletAuthVersion,
-      payload: walletAuthPayload
-    });
-    return walletAuthPayload;
-  };
-}
-function createWalletAuthAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
-      try {
-        let commandPayload = null;
-        const handleResponse = async (response) => {
-          ctx.events.unsubscribe("miniapp-wallet-auth" /* MiniAppWalletAuth */);
-          if (response.status === "success") {
-            await ctx.state.updateUserFromWalletAuth(response.address);
-          }
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-wallet-auth" /* MiniAppWalletAuth */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  };
-}
-
-// commands/index.ts
-function createCommands(ctx) {
-  return {
-    verify: createVerifyCommand(ctx),
-    pay: createPayCommand(ctx),
-    walletAuth: createWalletAuthCommand(ctx),
-    sendTransaction: createSendTransactionCommand(ctx),
-    signMessage: createSignMessageCommand(ctx),
-    signTypedData: createSignTypedDataCommand(ctx),
-    shareContacts: createShareContactsCommand(ctx),
-    requestPermission: createRequestPermissionCommand(ctx),
-    getPermissions: createGetPermissionsCommand(ctx),
-    sendHapticFeedback: createSendHapticFeedbackCommand(ctx),
-    share: createShareCommand(ctx),
-    chat: createChatCommand(ctx)
-  };
-}
-function createAsyncCommands(ctx, commands) {
-  return {
-    verify: createVerifyAsyncCommand(ctx, commands.verify),
-    pay: createPayAsyncCommand(ctx, commands.pay),
-    walletAuth: createWalletAuthAsyncCommand(ctx, commands.walletAuth),
-    sendTransaction: createSendTransactionAsyncCommand(
-      ctx,
-      commands.sendTransaction
-    ),
-    signMessage: createSignMessageAsyncCommand(ctx, commands.signMessage),
-    signTypedData: createSignTypedDataAsyncCommand(ctx, commands.signTypedData),
-    shareContacts: createShareContactsAsyncCommand(ctx, commands.shareContacts),
-    requestPermission: createRequestPermissionAsyncCommand(
-      ctx,
-      commands.requestPermission
-    ),
-    getPermissions: createGetPermissionsAsyncCommand(
-      ctx,
-      commands.getPermissions
-    ),
-    sendHapticFeedback: createSendHapticFeedbackAsyncCommand(
-      ctx,
-      commands.sendHapticFeedback
-    ),
-    share: createShareAsyncCommand(ctx, commands.share),
-    chat: createChatAsyncCommand(ctx, commands.chat)
-  };
-}
-
-// core/events.ts
-var import_idkit_core3 = require("@worldcoin/idkit-core");
-
-// helpers/proof/index.ts
-var import_viem2 = require("viem");
-var import_chains2 = require("viem/chains");
-var semaphoreVerifierAddress = "0x79f46b94d134109EbcbbddBAeD0E88790409A0e4";
-var semaphoreVerifierAbi = [
-  {
-    inputs: [
-      {
-        internalType: "uint256[8]",
-        name: "proof",
-        type: "uint256[8]"
-      }
-    ],
-    name: "compressProof",
-    outputs: [
-      {
-        internalType: "uint256[4]",
-        name: "compressed",
-        type: "uint256[4]"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var compressAndPadProof = async (proof, rpcUrl) => {
-  try {
-    const publicClient = (0, import_viem2.createPublicClient)({
-      chain: import_chains2.worldchain,
-      transport: (0, import_viem2.http)(
-        rpcUrl || "https://worldchain-mainnet.g.alchemy.com/public"
-      )
-    });
-    const decodedProof = (0, import_viem2.decodeAbiParameters)(
-      [{ type: "uint256[8]" }],
-      proof
-    )[0];
-    const compressedProof = await publicClient.readContract({
-      address: semaphoreVerifierAddress,
-      abi: semaphoreVerifierAbi,
-      functionName: "compressProof",
-      args: [decodedProof]
-    });
-    const paddedProof = [...compressedProof, 0n, 0n, 0n, 0n];
-    return (0, import_viem2.encodeAbiParameters)([{ type: "uint256[8]" }], [paddedProof]);
-  } catch (e) {
-    return proof;
-  }
-};
-
-// core/events.ts
-var EventManager = class {
-  constructor() {
-    this.listeners = {
-      ["miniapp-verify-action" /* MiniAppVerifyAction */]: () => {
-      },
-      ["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;
-    }
-    if (event === "miniapp-verify-action" /* MiniAppVerifyAction */) {
-      const handler = this.listeners[event];
-      this.unsubscribe(event);
-      this.processVerifyActionPayload(
-        payload,
-        handler
-      );
-      return;
-    }
-    this.listeners[event](payload);
-  }
-  async processVerifyActionPayload(payload, handler) {
-    if (payload.status === "error" && payload.error_code === "user_rejected") {
-      payload.error_code = import_idkit_core3.AppErrorCodes.VerificationRejected;
-    }
-    if (payload.status === "success") {
-      if ("verifications" in payload) {
-        const orbVerification = payload.verifications.find(
-          (v) => v.verification_level === import_idkit_core3.VerificationLevel.Orb
-        );
-        if (orbVerification) {
-          orbVerification.proof = await this.compressProofSafely(
-            orbVerification.proof,
-            {
-              mode: "multi",
-              payloadVersion: payload.version,
-              verificationsCount: payload.verifications.length,
-              verificationLevel: orbVerification.verification_level
-            }
-          );
-        }
-      } else if (payload.verification_level === import_idkit_core3.VerificationLevel.Orb) {
-        payload.proof = await this.compressProofSafely(
-          payload.proof,
-          {
-            mode: "single",
-            payloadVersion: payload.version,
-            verificationLevel: payload.verification_level
-          }
-        );
-      }
-    }
-    handler(payload);
-  }
-  async compressProofSafely(proof, context) {
-    try {
-      return await compressAndPadProof(proof);
-    } catch (error) {
-      console.error(
-        "Failed to compress verification proof. Delivering payload with uncompressed proof.",
-        {
-          ...context,
-          error
-        }
-      );
-      return proof;
-    }
+  if (siweMessageData.request_id) {
+    siweMessage += `Request ID: ${siweMessageData.request_id}
+`;
   }
+  return siweMessage;
 };
 
-// helpers/usernames/index.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 };
-};
-
-// types/init.ts
-var MiniAppLaunchLocation = /* @__PURE__ */ ((MiniAppLaunchLocation3) => {
-  MiniAppLaunchLocation3["Chat"] = "chat";
-  MiniAppLaunchLocation3["Home"] = "home";
-  MiniAppLaunchLocation3["AppStore"] = "app-store";
-  MiniAppLaunchLocation3["DeepLink"] = "deep-link";
-  MiniAppLaunchLocation3["WalletTab"] = "wallet-tab";
-  return MiniAppLaunchLocation3;
-})(MiniAppLaunchLocation || {});
-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 */
-};
-var mapWorldAppLaunchLocation = (location) => {
-  if (!location || typeof location !== "string") return null;
-  console.log("MiniKit launch location mapped:", location);
-  const normalizedLocation = location.toLowerCase();
-  return WORLD_APP_LAUNCH_LOCATION_MAP[normalizedLocation] ?? null;
+// 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;
+  }
 };
 
-// core/state.ts
-var MiniKitState = class {
-  constructor() {
-    this.appId = null;
-    this.user = {};
-    this.deviceProperties = {};
-    this.location = null;
-    this.isReady = false;
+// 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" };
   }
-  initFromWorldApp(worldApp) {
-    if (!worldApp) return;
-    this.user.optedIntoOptionalAnalytics = worldApp.is_optional_analytics;
-    this.user.deviceOS = worldApp.device_os;
-    this.user.worldAppVersion = worldApp.world_app_version;
-    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);
-  }
-  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);
-    }
+  if (params.nonce.length < 8) {
+    return { valid: false, message: "'nonce' must be at least 8 characters" };
   }
-  async getUserByAddress(address) {
-    const walletAddress = address ?? this.user.walletAddress;
-    const userProfile = await getUserProfile(walletAddress);
+  if (!SIWE_NONCE_REGEX2.test(params.nonce)) {
     return {
-      walletAddress,
-      username: userProfile.username,
-      profilePictureUrl: userProfile.profile_picture_url
+      valid: false,
+      message: "'nonce' must be alphanumeric (letters and numbers only)"
     };
   }
-  async getUserByUsername(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
-    };
+  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 };
 };
 
-// types/errors.ts
-var import_idkit_core4 = require("@worldcoin/idkit-core");
-var import_idkit_core5 = require("@worldcoin/idkit-core");
-var VerificationErrorMessage = {
-  [import_idkit_core4.AppErrorCodes.VerificationRejected]: "You've cancelled the request in World App.",
-  [import_idkit_core4.AppErrorCodes.MaxVerificationsReached]: "You have already verified the maximum number of times for this action.",
-  [import_idkit_core4.AppErrorCodes.CredentialUnavailable]: "It seems you do not have the verification level required by this app.",
-  [import_idkit_core4.AppErrorCodes.MalformedRequest]: "There was a problem with this request. Please try again or contact the app owner.",
-  [import_idkit_core4.AppErrorCodes.InvalidNetwork]: "Invalid network. If you are the app owner, visit docs.worldcoin.org/test for details.",
-  [import_idkit_core4.AppErrorCodes.InclusionProofFailed]: "There was an issue fetching your credential. Please try again.",
-  [import_idkit_core4.AppErrorCodes.InclusionProofPending]: "Your identity is still being registered. Please wait a few minutes and try again.",
-  [import_idkit_core4.AppErrorCodes.UnexpectedResponse]: "Unexpected response from your wallet. Please try again.",
-  [import_idkit_core4.AppErrorCodes.FailedByHostApp]: "Verification failed by the app. Please contact the app owner for details.",
-  [import_idkit_core4.AppErrorCodes.GenericError]: "Something unexpected went wrong. Please try again.",
-  [import_idkit_core4.AppErrorCodes.ConnectionFailed]: "Connection to your wallet failed. Please try again."
-};
-var MiniKitInstallErrorCodes = /* @__PURE__ */ ((MiniKitInstallErrorCodes2) => {
-  MiniKitInstallErrorCodes2["Unknown"] = "unknown";
-  MiniKitInstallErrorCodes2["AlreadyInstalled"] = "already_installed";
-  MiniKitInstallErrorCodes2["OutsideOfWorldApp"] = "outside_of_worldapp";
-  MiniKitInstallErrorCodes2["NotOnClient"] = "not_on_client";
-  MiniKitInstallErrorCodes2["AppOutOfDate"] = "app_out_of_date";
-  return MiniKitInstallErrorCodes2;
-})(MiniKitInstallErrorCodes || {});
-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/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
+  };
+}
 
-// helpers/microphone/index.ts
+// src/helpers/microphone.ts
 var microphoneSetupDone = false;
 var setupMicrophone = () => {
   if (microphoneSetupDone) {
@@ -1718,7 +1514,7 @@ var setupMicrophone = () => {
     const stream = await realGUM(constraints);
     const hasAudioTrack = stream.getAudioTracks().length > 0;
     if (hasAudioTrack) {
-      sendWebviewEvent({
+      sendMiniKitEvent({
         command: "microphone-stream-started",
         version: 1,
         payload: {
@@ -1730,7 +1526,7 @@ var setupMicrophone = () => {
         t.addEventListener("ended", () => {
           const allAudioTracksEnded = stream.getAudioTracks().every((track) => track.readyState === "ended");
           if (allAudioTracksEnded) {
-            sendWebviewEvent({
+            sendMiniKitEvent({
               command: "microphone-stream-ended",
               version: 1,
               payload: {
@@ -1758,7 +1554,7 @@ var setupMicrophone = () => {
         audioTracks.forEach((t) => {
           t.stop();
         });
-        sendWebviewEvent({
+        sendMiniKitEvent({
           command: "microphone-stream-ended",
           version: 1,
           payload: {
@@ -1779,40 +1575,253 @@ var setupMicrophone = () => {
   microphoneSetupDone = true;
 };
 
-// minikit.ts
+// 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.stateManager.appId;
+    return this._appId;
   }
   static set appId(value) {
-    this.stateManager.appId = value;
+    this._appId = value;
   }
   static get user() {
-    return this.stateManager.user;
+    return this._user;
   }
   static set user(value) {
-    this.stateManager.user = value;
+    this._user = value;
   }
   static get deviceProperties() {
-    return this.stateManager.deviceProperties;
+    return this._deviceProperties;
   }
   static get location() {
-    return this.stateManager.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.stateManager.updateUserFromWalletAuth(payload.address);
+          await this.updateUserFromWalletAuth(payload.address);
         }
         originalHandler(payload);
       };
@@ -1822,16 +1831,26 @@ var _MiniKit = class _MiniKit {
     }
   }
   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() {
-    sendWebviewEvent({
+    sendMiniKitEvent({
       command: "init",
       payload: {
         version: MINIKIT_VERSION,
@@ -1840,7 +1859,11 @@ var _MiniKit = class _MiniKit {
     });
   }
   static install(appId) {
-    if (typeof window === "undefined" || Boolean(window.MiniKit)) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.install(appId);
+    }
+    if (typeof window === "undefined") {
       return {
         success: false,
         errorCode: "already_installed" /* AlreadyInstalled */,
@@ -1850,7 +1873,7 @@ var _MiniKit = class _MiniKit {
     if (!appId) {
       console.warn("App ID not provided during install");
     } else {
-      this.stateManager.appId = appId;
+      this._appId = appId;
     }
     if (!window.WorldApp) {
       return {
@@ -1859,9 +1882,9 @@ var _MiniKit = class _MiniKit {
         errorMessage: MiniKitInstallErrorMessage["outside_of_worldapp" /* OutsideOfWorldApp */]
       };
     }
-    this.stateManager.initFromWorldApp(window.WorldApp);
+    this.initFromWorldApp(window.WorldApp);
     try {
-      window.MiniKit = _MiniKit;
+      window.MiniKit = this;
       this.sendInit();
     } catch (error) {
       console.error(
@@ -1874,7 +1897,7 @@ var _MiniKit = class _MiniKit {
         errorMessage: MiniKitInstallErrorMessage["unknown" /* Unknown */]
       };
     }
-    this.stateManager.isReady = true;
+    this._isReady = true;
     setupMicrophone();
     if (!validateCommands(window.WorldApp.supported_commands)) {
       return {
@@ -1886,9 +1909,9 @@ var _MiniKit = class _MiniKit {
     return { success: true };
   }
   static isInstalled(debug) {
-    const isInstalled = this.stateManager.isReady && Boolean(window.MiniKit);
+    const isInstalled = this._isReady && Boolean(window.MiniKit);
     if (!isInstalled) {
-      console.error(
+      console.warn(
         "MiniKit is not installed. Make sure you're running the application inside of World App"
       );
     }
@@ -1898,42 +1921,106 @@ var _MiniKit = class _MiniKit {
     return isInstalled;
   }
   // ============================================================================
-  // Commands
+  // 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: this.stateManager
+      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() {
-    if (!this.commandsInstance) {
-      this.commandsInstance = createCommands(this.getContext());
-    }
-    return this.commandsInstance;
+    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() {
-    if (!this.asyncCommandsInstance) {
-      this.asyncCommandsInstance = createAsyncCommands(
-        this.getContext(),
-        this.commands
-      );
-    }
-    return this.asyncCommandsInstance;
+    throw new Error(
+      "MiniKit.commandsAsync has been removed. Use MiniKit.pay(), MiniKit.walletAuth(), etc. directly."
+    );
   }
 };
 _MiniKit.eventManager = new EventManager();
-_MiniKit.stateManager = new MiniKitState();
-_MiniKit.commandsInstance = null;
-_MiniKit.asyncCommandsInstance = null;
+// 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) => {
-  return _MiniKit.stateManager.getUserByAddress(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) => {
-  return _MiniKit.stateManager.getUserByUsername(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) => {
@@ -1964,132 +2051,261 @@ _MiniKit.showProfileCard = (username, walletAddress) => {
 };
 var MiniKit = _MiniKit;
 
-// index.ts
-var import_idkit_core6 = require("@worldcoin/idkit-core");
-var import_backend = require("@worldcoin/idkit-core/backend");
-
-// helpers/address-book/index.ts
-var import_viem3 = require("viem");
-var import_chains3 = require("viem/chains");
-var worldIdAddressBookContractAddress = "0x57b930D551e677CC36e2fA036Ae2fe8FdaE0330D";
-var addressVerifiedUntilAbi = [
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      }
-    ],
-    name: "addressVerifiedUntil",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var getIsUserVerified = async (walletAddress, rpcUrl) => {
-  const publicClient = (0, import_viem3.createPublicClient)({
-    chain: import_chains3.worldchain,
-    transport: (0, import_viem3.http)(
-      rpcUrl || "https://worldchain-mainnet.g.alchemy.com/public"
-    )
-  });
+// 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 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 {
-    const verifiedUntilResponse = await publicClient.readContract({
-      address: worldIdAddressBookContractAddress,
-      abi: addressVerifiedUntilAbi,
-      functionName: "addressVerifiedUntil",
-      args: [walletAddress]
-    });
-    const verifiedUntil = Number(verifiedUntilResponse.toString());
-    if (!Number.isFinite(verifiedUntil)) {
-      console.warn("Invalid verifiedUntil value:", verifiedUntil);
-      return false;
+    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}`);
     }
-    const currentTime = Math.floor(Date.now() / 1e3);
-    return verifiedUntil > currentTime;
-  } catch (error) {
-    console.error("Error verifying user:", error);
-    return false;
   }
-};
+  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__;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  COMMAND_VERSIONS,
-  ChatErrorCodes,
-  ChatErrorMessage,
-  Command,
-  GetPermissionsErrorCodes,
-  GetPermissionsErrorMessage,
-  MiniAppLaunchLocation,
   MiniKit,
-  MiniKitInstallErrorCodes,
-  MiniKitInstallErrorMessage,
-  Network,
-  PaymentErrorCodes,
-  PaymentErrorMessage,
-  Permission,
-  RequestPermissionErrorCodes,
-  RequestPermissionErrorMessage,
-  ResponseEvent,
-  SendHapticFeedbackErrorCodes,
-  SendHapticFeedbackErrorMessage,
-  SendTransactionErrorCodes,
-  SendTransactionErrorMessage,
-  ShareContactsErrorCodes,
-  ShareContactsErrorMessage,
-  ShareFilesErrorCodes,
-  ShareFilesErrorMessage,
-  SignMessageErrorCodes,
-  SignMessageErrorMessage,
-  SignTypedDataErrorCodes,
-  SignTypedDataErrorMessage,
-  TokenDecimals,
-  Tokens,
-  VerificationErrorCodes,
-  VerificationLevel,
-  WalletAuthErrorCodes,
-  WalletAuthErrorMessage,
-  createAsyncCommands,
-  createChatAsyncCommand,
-  createChatCommand,
-  createCommands,
-  createGetPermissionsAsyncCommand,
-  createGetPermissionsCommand,
-  createPayAsyncCommand,
-  createPayCommand,
-  createRequestPermissionAsyncCommand,
-  createRequestPermissionCommand,
-  createSendHapticFeedbackAsyncCommand,
-  createSendHapticFeedbackCommand,
-  createSendTransactionAsyncCommand,
-  createSendTransactionCommand,
-  createShareAsyncCommand,
-  createShareCommand,
-  createShareContactsAsyncCommand,
-  createShareContactsCommand,
-  createSignMessageAsyncCommand,
-  createSignMessageCommand,
-  createSignTypedDataAsyncCommand,
-  createSignTypedDataCommand,
-  createVerifyAsyncCommand,
-  createVerifyCommand,
-  createWalletAuthAsyncCommand,
-  createWalletAuthCommand,
-  getIsUserVerified,
-  isCommandAvailable,
-  mapWorldAppLaunchLocation,
-  parseSiweMessage,
-  sendMiniKitEvent,
-  setCommandAvailable,
-  tokenToDecimals,
-  validateCommands,
-  verifyCloudProof,
-  verifySiweMessage
+  getWorldAppProvider
 });