@worldcoin/minikit-js 1.11.0 → 2.0.0-dev.1

package/build/index.cjs

@@ -17,137 +17,20 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// index.ts
-var core_exports = {};
-__export(core_exports, {
-  AttestationErrorCodes: () => AttestationErrorCodes,
-  AttestationErrorMessage: () => AttestationErrorMessage,
-  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,
-  createAttestationAsyncCommand: () => createAttestationAsyncCommand,
-  createAttestationCommand: () => createAttestationCommand,
-  createChatAsyncCommand: () => createChatAsyncCommand,
-  createChatCommand: () => createChatCommand,
-  createCloseMiniAppCommand: () => createCloseMiniAppCommand,
-  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";
-  Command2["Attestation"] = "attestation";
-  Command2["CloseMiniApp"] = "close-miniapp";
-  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";
-  ResponseEvent3["MiniAppAttestation"] = "miniapp-attestation";
-  return ResponseEvent3;
-})(ResponseEvent || {});
+// src/commands/types.ts
 var COMMAND_VERSIONS = {
-  ["verify" /* Verify */]: 1,
+  ["attestation" /* Attestation */]: 1,
   ["pay" /* Pay */]: 1,
   ["wallet-auth" /* WalletAuth */]: 2,
-  ["send-transaction" /* SendTransaction */]: 1,
+  ["send-transaction" /* SendTransaction */]: 2,
   ["sign-message" /* SignMessage */]: 1,
   ["sign-typed-data" /* SignTypedData */]: 1,
   ["share-contacts" /* ShareContacts */]: 1,
@@ -156,11 +39,10 @@ var COMMAND_VERSIONS = {
   ["send-haptic-feedback" /* SendHapticFeedback */]: 1,
   ["share" /* Share */]: 1,
   ["chat" /* Chat */]: 1,
-  ["attestation" /* Attestation */]: 1,
   ["close-miniapp" /* CloseMiniApp */]: 1
 };
 var commandAvailability = {
-  ["verify" /* Verify */]: false,
+  ["attestation" /* Attestation */]: false,
   ["pay" /* Pay */]: false,
   ["wallet-auth" /* WalletAuth */]: false,
   ["send-transaction" /* SendTransaction */]: false,
@@ -172,11 +54,10 @@ var commandAvailability = {
   ["send-haptic-feedback" /* SendHapticFeedback */]: false,
   ["share" /* Share */]: false,
   ["chat" /* Chat */]: false,
-  ["attestation" /* Attestation */]: false,
   ["close-miniapp" /* CloseMiniApp */]: false
 };
 function isCommandAvailable(command) {
-  return commandAvailability[command];
+  return commandAvailability[command] ?? false;
 }
 function setCommandAvailable(command, available) {
   commandAvailability[command] = available;
@@ -211,227 +92,357 @@ 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/attestation.ts
-var AttestationErrorCodes = /* @__PURE__ */ ((AttestationErrorCodes2) => {
-  AttestationErrorCodes2["Unauthorized"] = "unauthorized";
-  AttestationErrorCodes2["AttestationFailed"] = "attestation_failed";
-  AttestationErrorCodes2["IntegrityFailed"] = "integrity_failed";
-  AttestationErrorCodes2["InvalidInput"] = "invalid_input";
-  AttestationErrorCodes2["UnsupportedVersion"] = "unsupported_version";
-  return AttestationErrorCodes2;
-})(AttestationErrorCodes || {});
-var AttestationErrorMessage = {
-  ["unauthorized" /* Unauthorized */]: "App is not whitelisted for attestation.",
-  ["attestation_failed" /* AttestationFailed */]: "Failed to obtain token from attestation gateway.",
-  ["integrity_failed" /* IntegrityFailed */]: "Platform integrity check failed.",
-  ["invalid_input" /* InvalidInput */]: "Invalid request payload.",
-  ["unsupported_version" /* UnsupportedVersion */]: "Command version is not supported."
+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 createAttestationCommand(_ctx) {
-  return (input) => {
-    if (typeof window === "undefined" || !isCommandAvailable("attestation" /* Attestation */)) {
+
+// src/events.ts
+var EventManager = class {
+  constructor() {
+    this.listeners = {
+      ["miniapp-attestation" /* MiniAppAttestation */]: () => {
+      },
+      ["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(
-        "'attestation' command is unavailable. Check MiniKit.install() or update the app version"
+        `No handler for event ${event}, payload: ${JSON.stringify(payload)}`
       );
-      return null;
+      return;
+    }
+    this.listeners[event](payload);
+  }
+};
+
+// src/commands/fallback.ts
+async function executeWithFallback(options) {
+  const {
+    command,
+    nativeExecutor,
+    wagmiFallback,
+    customFallback,
+    requiresFallback = false
+  } = options;
+  const inWorldApp = isInWorldApp();
+  const commandAvailable = isCommandAvailable(command);
+  let nativeError;
+  if (inWorldApp && commandAvailable) {
+    try {
+      const data = await nativeExecutor();
+      return { data, executedWith: "minikit" };
+    } catch (error) {
+      nativeError = error;
+      console.warn(`Native ${command} failed, attempting fallback:`, error);
     }
-    if (!input.requestHash || input.requestHash.length === 0) {
-      console.error("'attestation' command requires a non-empty requestHash");
-      return null;
+  }
+  if (!inWorldApp && wagmiFallback) {
+    try {
+      const data = await wagmiFallback();
+      return { data, executedWith: "wagmi" };
+    } catch (error) {
+      console.warn(`Wagmi fallback for ${command} failed:`, error);
     }
-    const payload = {
-      request_hash: input.requestHash
-    };
-    sendMiniKitEvent({
-      command: "attestation" /* Attestation */,
-      version: COMMAND_VERSIONS["attestation" /* Attestation */],
-      payload
-    });
-    return payload;
+  }
+  if (!inWorldApp && 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/attestation/types.ts
+var AttestationError = class extends Error {
+  constructor(error_code) {
+    super(`Attestation failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "AttestationError";
+  }
+};
+
+// src/commands/attestation/index.ts
+async function attestation(options, ctx) {
+  const result = await executeWithFallback({
+    command: "attestation" /* Attestation */,
+    nativeExecutor: () => nativeAttestation(options, ctx),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
   };
 }
-function createAttestationAsyncCommand(ctx, syncCommand) {
-  return async (input) => {
-    return new Promise((resolve, reject) => {
+async function nativeAttestation(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("attestation" /* Attestation */)) {
+    throw new Error(
+      "'attestation' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  if (!options.requestHash || options.requestHash.length === 0) {
+    throw new Error("'attestation' command requires a non-empty requestHash");
+  }
+  const payload = await new Promise(
+    (resolve, reject) => {
       try {
-        const handleResponse = (response) => {
-          ctx.events.unsubscribe("miniapp-attestation" /* MiniAppAttestation */);
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-attestation" /* MiniAppAttestation */,
-          handleResponse
-        );
-        const commandPayload = syncCommand(input);
-        if (!commandPayload) {
+        ctx.events.subscribe("miniapp-attestation" /* MiniAppAttestation */, (response) => {
           ctx.events.unsubscribe("miniapp-attestation" /* MiniAppAttestation */);
-          reject(
-            new Error(
-              "'attestation' command failed: command unavailable or invalid input"
-            )
-          );
-        }
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "attestation" /* Attestation */,
+          version: COMMAND_VERSIONS["attestation" /* Attestation */],
+          payload: {
+            request_hash: options.requestHash
+          }
+        });
       } catch (error) {
-        ctx.events.unsubscribe("miniapp-attestation" /* MiniAppAttestation */);
         reject(error);
       }
-    });
-  };
+    }
+  );
+  if (payload.status === "error") {
+    throw new AttestationError(payload.error_code);
+  }
+  return 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."
+// 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";
+  }
 };
-function createChatCommand(_ctx) {
-  return (payload) => {
-    if (typeof window === "undefined" || !isCommandAvailable("chat" /* Chat */)) {
-      console.error(
-        "'chat' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
-    }
-    if (payload.message.length === 0) {
-      console.error("'chat' command requires a non-empty message");
-      return null;
-    }
-    sendMiniKitEvent({
-      command: "chat" /* Chat */,
-      version: COMMAND_VERSIONS["chat" /* Chat */],
-      payload
-    });
-    return payload;
+
+// 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
   };
 }
-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 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;
 }
 
-// commands/close-miniapp.ts
-function createCloseMiniAppCommand(_ctx) {
-  return () => {
-    if (typeof window === "undefined" || !isCommandAvailable("close-miniapp" /* CloseMiniApp */)) {
-      console.error(
-        "'closeMiniApp' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return false;
-    }
-    sendMiniKitEvent({
-      command: "close-miniapp" /* CloseMiniApp */,
-      version: COMMAND_VERSIONS["close-miniapp" /* CloseMiniApp */],
-      payload: {}
-    });
-    return true;
+// src/commands/close-miniapp/index.ts
+async function closeMiniApp(options = {}, _ctx) {
+  const result = await executeWithFallback({
+    command: "close-miniapp" /* CloseMiniApp */,
+    nativeExecutor: () => nativeCloseMiniApp(),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeCloseMiniApp() {
+  if (typeof window === "undefined" || !isCommandAvailable("close-miniapp" /* CloseMiniApp */)) {
+    throw new Error(
+      "'closeMiniApp' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  sendMiniKitEvent({
+    command: "close-miniapp" /* CloseMiniApp */,
+    version: COMMAND_VERSIONS["close-miniapp" /* CloseMiniApp */],
+    payload: {}
+  });
+  return {
+    status: "success",
+    version: COMMAND_VERSIONS["close-miniapp" /* CloseMiniApp */]
   };
 }
 
-// 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."
+// 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";
+  }
 };
-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"
-      );
-      return null;
-    }
-    sendMiniKitEvent({
-      command: "get-permissions" /* GetPermissions */,
-      version: COMMAND_VERSIONS["get-permissions" /* GetPermissions */],
-      payload: {}
-    });
-    return {
-      status: "sent"
-    };
+
+// 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
@@ -449,188 +460,210 @@ 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;
+
+// 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
   };
 }
-function createSendHapticFeedbackAsyncCommand(ctx, syncCommand) {
-  return async (payload) => {
-    return new Promise((resolve, reject) => {
+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 {
-        let commandPayload = null;
-        const handleResponse = (response) => {
+        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);
-      } catch (error) {
-        reject(error);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "send-haptic-feedback" /* SendHapticFeedback */,
+          version: COMMAND_VERSIONS["send-haptic-feedback" /* SendHapticFeedback */],
+          payload: payloadInput
+        });
+      } catch (error) {
+        reject(error);
       }
-    });
-  };
+    }
+  );
+  if (payload.status === "error") {
+    throw new SendHapticFeedbackError(payload.error_code);
+  }
+  return payload;
+}
+
+// src/commands/fallback-adapter-registry.ts
+var FALLBACK_ADAPTER_KEY = "__minikit_fallback_adapter__";
+function getFallbackAdapter() {
+  return globalThis[FALLBACK_ADAPTER_KEY];
 }
 
-// helpers/transaction/validate-payload.ts
+// src/commands/send-transaction/types.ts
+var SendTransactionError = class extends Error {
+  constructor(code, details) {
+    super(`Transaction failed: ${code}`);
+    this.name = "SendTransactionError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/commands/send-transaction/validate.ts
 var isValidHex = (str) => {
   return /^0x[0-9A-Fa-f]+$/.test(str);
 };
-var objectValuesToArrayRecursive = (input) => {
-  if (input === null || typeof input !== "object") {
-    return input;
-  }
-  if (Array.isArray(input)) {
-    return input.map((item) => objectValuesToArrayRecursive(item));
-  }
-  const values = Object.values(input);
-  return values.map((value) => objectValuesToArrayRecursive(value));
-};
 var processPayload = (payload) => {
   if (typeof payload === "boolean" || typeof payload === "string" || payload === null || payload === void 0) {
     return payload;
@@ -643,6 +676,20 @@ var processPayload = (payload) => {
   }
   if (typeof payload === "object") {
     const result = { ...payload };
+    if ("chainId" in result && result.chainId !== void 0) {
+      if (typeof result.chainId === "string") {
+        const parsed = Number(result.chainId);
+        if (Number.isFinite(parsed)) {
+          result.chainId = parsed;
+        }
+      } else if (typeof result.chainId === "bigint") {
+        const parsed = Number(result.chainId);
+        if (!Number.isSafeInteger(parsed)) {
+          throw new Error(`Invalid chainId: ${String(result.chainId)}`);
+        }
+        result.chainId = parsed;
+      }
+    }
     if ("value" in result && result.value !== void 0) {
       if (typeof result.value !== "string") {
         result.value = String(result.value);
@@ -659,6 +706,7 @@ var processPayload = (payload) => {
     }
     for (const key in result) {
       if (Object.prototype.hasOwnProperty.call(result, key)) {
+        if (key === "chainId") continue;
         result[key] = processPayload(result[key]);
       }
     }
@@ -667,92 +715,153 @@ var processPayload = (payload) => {
   return payload;
 };
 var validateSendTransactionPayload = (payload) => {
-  if (payload.formatPayload) {
-    const formattedPayload = processPayload(payload);
-    formattedPayload.transaction = formattedPayload.transaction.map((tx) => {
-      const args = objectValuesToArrayRecursive(tx.args);
-      return {
-        ...tx,
-        args
-      };
-    });
-    return formattedPayload;
-  }
-  return payload;
+  return processPayload(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.";
+function resolveChainId(options) {
+  return options.chainId;
+}
+function resolveTransactions(options) {
+  if (options.transactions.length === 0) {
+    throw new SendTransactionError("input_error" /* InputError */, {
+      reason: "At least one transaction is required. Use `transactions: [{ to, data, value }]`."
+    });
+  }
+  return options.transactions;
+}
+function normalizeSendTransactionOptions(options) {
+  const chainId = resolveChainId(options);
+  if (chainId !== WORLD_CHAIN_ID) {
+    throw new SendTransactionError("invalid_operation" /* InvalidOperation */, {
+      reason: `World App only supports World Chain (chainId: ${WORLD_CHAIN_ID})`
+    });
+  }
+  return {
+    transactions: resolveTransactions(options),
+    chainId
+  };
+}
+async function sendTransaction(options, ctx) {
+  const normalizedOptions = normalizeSendTransactionOptions(options);
+  const fallbackAdapter = getFallbackAdapter();
+  const isWagmiFallbackPath = !isInWorldApp() && Boolean(fallbackAdapter?.sendTransaction);
+  if (isWagmiFallbackPath && normalizedOptions.transactions.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(normalizedOptions, ctx),
+    wagmiFallback: fallbackAdapter?.sendTransaction ? () => adapterSendTransactionFallback(normalizedOptions) : void 0,
+    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 !== WORLD_CHAIN_ID) {
+    throw new Error(
+      `World App only supports World Chain (chainId: ${WORLD_CHAIN_ID})`
+    );
+  }
+  const commandInput = window.WorldApp?.supported_commands.find(
+    (command) => command.name === "send-transaction" /* SendTransaction */
+  );
+  if (commandInput && !commandInput.supported_versions.includes(
+    COMMAND_VERSIONS["send-transaction" /* SendTransaction */]
+  )) {
+    throw new CommandUnavailableError("send-transaction" /* SendTransaction */, "oldAppVersion");
+  }
+  const input = {
+    transactions: options.transactions,
+    chainId: options.chainId
+  };
+  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
+    );
+  }
+  const successPayload = finalPayload;
+  return {
+    userOpHash: String(successPayload.userOpHash ?? ""),
+    status: finalPayload.status,
+    version: finalPayload.version,
+    from: String(successPayload.from ?? ""),
+    timestamp: String(successPayload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString())
+  };
+}
+async function adapterSendTransactionFallback(options) {
+  if (options.transactions.length > 1) {
+    throw new Error(WAGMI_MULTI_TX_ERROR_MESSAGE);
+  }
+  const firstTransaction = options.transactions[0];
+  if (!firstTransaction) {
+    throw new Error("At least one transaction is required");
+  }
+  const fallbackAdapter = getFallbackAdapter();
+  if (!fallbackAdapter?.sendTransaction) {
+    throw new Error("Fallback adapter is not registered.");
+  }
+  const result = await fallbackAdapter.sendTransaction({
+    transaction: {
+      address: firstTransaction.to,
+      data: firstTransaction.data,
+      value: firstTransaction.value
+    },
+    chainId: options.chainId
+  });
+  return {
+    userOpHash: result.transactionHash,
+    status: "success",
+    version: COMMAND_VERSIONS["send-transaction" /* SendTransaction */],
+    from: "",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
 
-// 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;
@@ -818,414 +927,292 @@ 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 fallbackAdapter = getFallbackAdapter();
+  const result = await executeWithFallback({
+    command: "sign-message" /* SignMessage */,
+    nativeExecutor: () => nativeSignMessage(options, ctx),
+    wagmiFallback: fallbackAdapter?.signMessage ? () => fallbackAdapter.signMessage({
+      message: options.message
+    }) : void 0,
+    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) => {
-    console.warn(
-      "signTypedData is deprecated. Use signMessage or sendTransaction instead."
-    );
-    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 fallbackAdapter = getFallbackAdapter();
+  const result = await executeWithFallback({
+    command: "sign-typed-data" /* SignTypedData */,
+    nativeExecutor: () => nativeSignTypedData(options, ctx),
+    wagmiFallback: fallbackAdapter?.signTypedData ? () => fallbackAdapter.signTypedData({
+      types: options.types,
+      primaryType: options.primaryType,
+      message: options.message,
+      domain: options.domain,
+      chainId: options.chainId
+    }) : void 0,
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  if (result.executedWith === "wagmi") {
+    return {
+      executedWith: "wagmi",
+      data: result.data
     };
-    ctx.events.setVerifyActionProcessingOptions({
-      skip_proof_compression: payload.skip_proof_compression
-    });
-    sendMiniKitEvent({
-      command: "verify" /* Verify */,
-      version: COMMAND_VERSIONS["verify" /* Verify */],
-      payload: eventPayload
-    });
-    return eventPayload;
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
   };
 }
-function createVerifyAsyncCommand(ctx, syncCommand) {
-  let hasInFlightVerifyRequest = false;
-  return async (payload) => {
-    if (hasInFlightVerifyRequest) {
-      return Promise.reject(
-        new Error(
-          "A verify request is already in flight. Wait for the current request to complete before sending another."
-        )
-      );
-    }
-    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 {
-        hasInFlightVerifyRequest = true;
-        let commandPayload = null;
-        const handleResponse = (response) => {
-          ctx.events.unsubscribe("miniapp-verify-action" /* MiniAppVerifyAction */);
-          hasInFlightVerifyRequest = false;
-          resolve({ commandPayload, finalPayload: response });
-        };
-        ctx.events.subscribe(
-          "miniapp-verify-action" /* MiniAppVerifyAction */,
-          handleResponse
-        );
-        commandPayload = syncCommand(payload);
-        if (commandPayload === null) {
-          ctx.events.unsubscribe("miniapp-verify-action" /* MiniAppVerifyAction */);
-          hasInFlightVerifyRequest = false;
-          reject(
-            new Error(
-              "Failed to send verify command. Ensure MiniKit is installed and the verify command is available."
-            )
-          );
-        }
+        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) {
-        hasInFlightVerifyRequest = false;
         reject(error);
       }
-    });
-  };
+    }
+  );
+  if (payload.status === "error") {
+    throw new SignTypedDataError(payload.error_code);
+  }
+  return payload;
 }
 
-// helpers/siwe/siwe.ts
+// src/commands/wallet-auth/siwe.ts
 var import_viem = 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) {
@@ -1266,577 +1253,150 @@ var generateSiweMessage = (siweMessageData) => {
 `;
   }
   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),
-    /** @deprecated EIP-712 typed data signing is deprecated. Use signMessage or sendTransaction instead. */
-    signTypedData: createSignTypedDataCommand(ctx),
-    shareContacts: createShareContactsCommand(ctx),
-    requestPermission: createRequestPermissionCommand(ctx),
-    getPermissions: createGetPermissionsCommand(ctx),
-    sendHapticFeedback: createSendHapticFeedbackCommand(ctx),
-    share: createShareCommand(ctx),
-    chat: createChatCommand(ctx),
-    attestation: createAttestationCommand(ctx),
-    closeMiniApp: createCloseMiniAppCommand(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),
-    /** @deprecated EIP-712 typed data signing is deprecated. Use signMessage or sendTransaction instead. */
-    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),
-    attestation: createAttestationAsyncCommand(ctx, commands.attestation)
-  };
-}
-
-// 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 */]: () => {
-      },
-      ["miniapp-attestation" /* MiniAppAttestation */]: () => {
-      }
-    };
-    this.verifyActionProcessingOptionsQueue = [];
-  }
-  subscribe(event, handler) {
-    this.listeners[event] = handler;
-  }
-  unsubscribe(event) {
-    delete this.listeners[event];
-  }
-  setVerifyActionProcessingOptions(options) {
-    this.verifyActionProcessingOptionsQueue.push({
-      skip_proof_compression: Boolean(options?.skip_proof_compression ?? false)
-    });
-  }
-  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];
-      const processingOptions = this.verifyActionProcessingOptionsQueue.shift() ?? {
-        skip_proof_compression: false
-      };
-      this.processVerifyActionPayload(
-        payload,
-        handler,
-        processingOptions
-      );
-      return;
-    }
-    this.listeners[event](payload);
-  }
-  async processVerifyActionPayload(payload, handler, processingOptions) {
-    if (payload.status === "error" && payload.error_code === "user_rejected") {
-      payload.error_code = import_idkit_core3.AppErrorCodes.VerificationRejected;
-    }
-    if (payload.status === "success" && !processingOptions.skip_proof_compression) {
-      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;
-    }
+    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_REGEX = /^[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.preferredCurrency = worldApp.preferred_currency;
-    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_REGEX.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 fallbackAdapter = getFallbackAdapter();
+  const result = await executeWithFallback({
+    command: "wallet-auth" /* WalletAuth */,
+    nativeExecutor: () => nativeWalletAuth(options, ctx),
+    wagmiFallback: fallbackAdapter?.walletAuth ? () => fallbackAdapter.walletAuth({
+      nonce: options.nonce,
+      statement: options.statement,
+      expirationTime: options.expirationTime
+    }) : void 0,
+    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) {
@@ -1859,7 +1419,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: {
@@ -1871,7 +1431,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: {
@@ -1899,7 +1459,7 @@ var setupMicrophone = () => {
         audioTracks.forEach((t) => {
           t.stop();
         });
-        sendWebviewEvent({
+        sendMiniKitEvent({
           command: "microphone-stream-ended",
           version: 1,
           payload: {
@@ -1920,40 +1480,272 @@ 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,
+   *   transactions: [{
+   *     to: '0x...',
+   *     data: '0x...',
+   *     value: '0x0',
+   *   }],
+   * });
+   * ```
+   */
+  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());
+  }
+  /**
+   * Request app attestation token for a request hash
+   */
+  static attestation(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.attestation(options);
+    }
+    return attestation(options, this.getContext());
+  }
+  /**
+   * Close the mini app
+   */
+  static closeMiniApp(options = {}) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.closeMiniApp(options);
+    }
+    return closeMiniApp(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);
       };
@@ -1963,16 +1755,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,
@@ -1981,7 +1783,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 */,
@@ -1991,7 +1797,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 {
@@ -2000,9 +1806,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(
@@ -2015,7 +1821,7 @@ var _MiniKit = class _MiniKit {
         errorMessage: MiniKitInstallErrorMessage["unknown" /* Unknown */]
       };
     }
-    this.stateManager.isReady = true;
+    this._isReady = true;
     setupMicrophone();
     if (!validateCommands(window.WorldApp.supported_commands)) {
       return {
@@ -2027,9 +1833,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"
       );
     }
@@ -2039,42 +1845,108 @@ 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)`
+   * - `MiniKit.commands.attestation(payload)` → `await MiniKit.attestation(options)`
+   * - `MiniKit.commands.closeMiniApp()` → `await MiniKit.closeMiniApp()`
+   */
   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) => {
@@ -2105,137 +1977,272 @@ _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
+var import_viem2 = require("viem");
+function _getAddress() {
+  if (typeof window === "undefined") return void 0;
+  return window.__worldapp_eip1193_address__;
+}
+function _setAddress(addr) {
+  if (typeof window === "undefined") return;
   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;
+    window.__worldapp_eip1193_address__ = (0, import_viem2.getAddress)(addr);
+  } catch {
+    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 {
+    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() || !MiniKit.isInstalled()) {
+      throw rpcError(
+        4900,
+        "World App provider only works inside World App and must be installed"
+      );
+    }
+    try {
+      const result = await MiniKit.walletAuth({
+        nonce: crypto.randomUUID().replace(/-/g, ""),
+        statement: "Sign in with World App"
+      });
+      _setAddress(result.data.address);
+      const addr = _getAddress();
+      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);
+          if (tx.chainId !== void 0 && tx.chainId !== 480) {
+            throw rpcError(4902, "World App only supports World Chain (480)");
+          }
+          try {
+            const result = await MiniKit.sendTransaction({
+              chainId: tx.chainId ?? 480,
+              transactions: [
+                {
+                  to: tx.to,
+                  ...tx.data && tx.data !== "0x" ? { data: tx.data } : {},
+                  value: tx.value
+                }
+              ]
+            });
+            return result.data.userOpHash;
+          } 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 = {
-  AttestationErrorCodes,
-  AttestationErrorMessage,
-  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,
-  createAttestationAsyncCommand,
-  createAttestationCommand,
-  createChatAsyncCommand,
-  createChatCommand,
-  createCloseMiniAppCommand,
-  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
 });