@worldcoin/minikit-js 1.9.9 → 1.9.10

package/build/index.cjs

@@ -20,13 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var core_exports = {};
 __export(core_exports, {
+  COMMAND_VERSIONS: () => COMMAND_VERSIONS,
   ChatErrorCodes: () => ChatErrorCodes,
   ChatErrorMessage: () => ChatErrorMessage,
   Command: () => Command,
   GetPermissionsErrorCodes: () => GetPermissionsErrorCodes,
   GetPermissionsErrorMessage: () => GetPermissionsErrorMessage,
-  MicrophoneErrorCodes: () => MicrophoneErrorCodes,
-  MicrophoneErrorMessage: () => MicrophoneErrorMessage,
   MiniAppLaunchLocation: () => MiniAppLaunchLocation,
   MiniKit: () => MiniKit,
   MiniKitInstallErrorCodes: () => MiniKitInstallErrorCodes,
@@ -34,7 +33,6 @@ __export(core_exports, {
   Network: () => Network,
   PaymentErrorCodes: () => PaymentErrorCodes,
   PaymentErrorMessage: () => PaymentErrorMessage,
-  PaymentValidationErrors: () => PaymentValidationErrors,
   Permission: () => Permission,
   RequestPermissionErrorCodes: () => RequestPermissionErrorCodes,
   RequestPermissionErrorMessage: () => RequestPermissionErrorMessage,
@@ -54,23 +52,48 @@ __export(core_exports, {
   TokenDecimals: () => TokenDecimals,
   Tokens: () => Tokens,
   VerificationErrorCodes: () => import_idkit_core2.AppErrorCodes,
-  VerificationErrorMessage: () => VerificationErrorMessage,
-  VerificationLevel: () => import_idkit_core4.VerificationLevel,
+  VerificationLevel: () => import_idkit_core6.VerificationLevel,
   WalletAuthErrorCodes: () => WalletAuthErrorCodes,
   WalletAuthErrorMessage: () => WalletAuthErrorMessage,
+  createAsyncCommands: () => createAsyncCommands,
+  createChatAsyncCommand: () => createChatAsyncCommand,
+  createChatCommand: () => createChatCommand,
+  createCommands: () => createCommands,
+  createGetPermissionsAsyncCommand: () => createGetPermissionsAsyncCommand,
+  createGetPermissionsCommand: () => createGetPermissionsCommand,
+  createPayAsyncCommand: () => createPayAsyncCommand,
+  createPayCommand: () => createPayCommand,
+  createRequestPermissionAsyncCommand: () => createRequestPermissionAsyncCommand,
+  createRequestPermissionCommand: () => createRequestPermissionCommand,
+  createSendHapticFeedbackAsyncCommand: () => createSendHapticFeedbackAsyncCommand,
+  createSendHapticFeedbackCommand: () => createSendHapticFeedbackCommand,
+  createSendTransactionAsyncCommand: () => createSendTransactionAsyncCommand,
+  createSendTransactionCommand: () => createSendTransactionCommand,
+  createShareAsyncCommand: () => createShareAsyncCommand,
+  createShareCommand: () => createShareCommand,
+  createShareContactsAsyncCommand: () => createShareContactsAsyncCommand,
+  createShareContactsCommand: () => createShareContactsCommand,
+  createSignMessageAsyncCommand: () => createSignMessageAsyncCommand,
+  createSignMessageCommand: () => createSignMessageCommand,
+  createSignTypedDataAsyncCommand: () => createSignTypedDataAsyncCommand,
+  createSignTypedDataCommand: () => createSignTypedDataCommand,
+  createVerifyAsyncCommand: () => createVerifyAsyncCommand,
+  createVerifyCommand: () => createVerifyCommand,
+  createWalletAuthAsyncCommand: () => createWalletAuthAsyncCommand,
+  createWalletAuthCommand: () => createWalletAuthCommand,
   getIsUserVerified: () => getIsUserVerified,
+  isCommandAvailable: () => isCommandAvailable,
   mapWorldAppLaunchLocation: () => mapWorldAppLaunchLocation,
   parseSiweMessage: () => parseSiweMessage,
+  sendMiniKitEvent: () => sendMiniKitEvent,
+  setCommandAvailable: () => setCommandAvailable,
   tokenToDecimals: () => tokenToDecimals,
+  validateCommands: () => validateCommands,
   verifyCloudProof: () => import_backend.verifyCloudProof,
   verifySiweMessage: () => verifySiweMessage
 });
 module.exports = __toCommonJS(core_exports);
 
-// minikit.ts
-var import_idkit_core3 = require("@worldcoin/idkit-core");
-var import_hashing = require("@worldcoin/idkit-core/hashing");
-
 // helpers/send-webview-event.ts
 var sendWebviewEvent = (payload) => {
   if (window.webkit) {
@@ -80,22 +103,255 @@ var sendWebviewEvent = (payload) => {
   }
 };
 
-// types/errors.ts
-var import_idkit_core = require("@worldcoin/idkit-core");
-var import_idkit_core2 = require("@worldcoin/idkit-core");
-var VerificationErrorMessage = {
-  [import_idkit_core.AppErrorCodes.VerificationRejected]: "You've cancelled the request in World App.",
-  [import_idkit_core.AppErrorCodes.MaxVerificationsReached]: "You have already verified the maximum number of times for this action.",
-  [import_idkit_core.AppErrorCodes.CredentialUnavailable]: "It seems you do not have the verification level required by this app.",
-  [import_idkit_core.AppErrorCodes.MalformedRequest]: "There was a problem with this request. Please try again or contact the app owner.",
-  [import_idkit_core.AppErrorCodes.InvalidNetwork]: "Invalid network. If you are the app owner, visit docs.worldcoin.org/test for details.",
-  [import_idkit_core.AppErrorCodes.InclusionProofFailed]: "There was an issue fetching your credential. Please try again.",
-  [import_idkit_core.AppErrorCodes.InclusionProofPending]: "Your identity is still being registered. Please wait a few minutes and try again.",
-  [import_idkit_core.AppErrorCodes.UnexpectedResponse]: "Unexpected response from your wallet. Please try again.",
-  [import_idkit_core.AppErrorCodes.FailedByHostApp]: "Verification failed by the app. Please contact the app owner for details.",
-  [import_idkit_core.AppErrorCodes.GenericError]: "Something unexpected went wrong. Please try again.",
-  [import_idkit_core.AppErrorCodes.ConnectionFailed]: "Connection to your wallet failed. Please try again."
+// commands/types.ts
+var Command = /* @__PURE__ */ ((Command2) => {
+  Command2["Verify"] = "verify";
+  Command2["Pay"] = "pay";
+  Command2["WalletAuth"] = "wallet-auth";
+  Command2["SendTransaction"] = "send-transaction";
+  Command2["SignMessage"] = "sign-message";
+  Command2["SignTypedData"] = "sign-typed-data";
+  Command2["ShareContacts"] = "share-contacts";
+  Command2["RequestPermission"] = "request-permission";
+  Command2["GetPermissions"] = "get-permissions";
+  Command2["SendHapticFeedback"] = "send-haptic-feedback";
+  Command2["Share"] = "share";
+  Command2["Chat"] = "chat";
+  return Command2;
+})(Command || {});
+var ResponseEvent = /* @__PURE__ */ ((ResponseEvent3) => {
+  ResponseEvent3["MiniAppVerifyAction"] = "miniapp-verify-action";
+  ResponseEvent3["MiniAppPayment"] = "miniapp-payment";
+  ResponseEvent3["MiniAppWalletAuth"] = "miniapp-wallet-auth";
+  ResponseEvent3["MiniAppSendTransaction"] = "miniapp-send-transaction";
+  ResponseEvent3["MiniAppSignMessage"] = "miniapp-sign-message";
+  ResponseEvent3["MiniAppSignTypedData"] = "miniapp-sign-typed-data";
+  ResponseEvent3["MiniAppShareContacts"] = "miniapp-share-contacts";
+  ResponseEvent3["MiniAppRequestPermission"] = "miniapp-request-permission";
+  ResponseEvent3["MiniAppGetPermissions"] = "miniapp-get-permissions";
+  ResponseEvent3["MiniAppSendHapticFeedback"] = "miniapp-send-haptic-feedback";
+  ResponseEvent3["MiniAppShare"] = "miniapp-share";
+  ResponseEvent3["MiniAppMicrophone"] = "miniapp-microphone";
+  ResponseEvent3["MiniAppChat"] = "miniapp-chat";
+  return ResponseEvent3;
+})(ResponseEvent || {});
+var COMMAND_VERSIONS = {
+  ["verify" /* Verify */]: 1,
+  ["pay" /* Pay */]: 1,
+  ["wallet-auth" /* WalletAuth */]: 2,
+  ["send-transaction" /* SendTransaction */]: 1,
+  ["sign-message" /* SignMessage */]: 1,
+  ["sign-typed-data" /* SignTypedData */]: 1,
+  ["share-contacts" /* ShareContacts */]: 1,
+  ["request-permission" /* RequestPermission */]: 1,
+  ["get-permissions" /* GetPermissions */]: 1,
+  ["send-haptic-feedback" /* SendHapticFeedback */]: 1,
+  ["share" /* Share */]: 1,
+  ["chat" /* Chat */]: 1
+};
+var commandAvailability = {
+  ["verify" /* Verify */]: false,
+  ["pay" /* Pay */]: false,
+  ["wallet-auth" /* WalletAuth */]: false,
+  ["send-transaction" /* SendTransaction */]: false,
+  ["sign-message" /* SignMessage */]: false,
+  ["sign-typed-data" /* SignTypedData */]: false,
+  ["share-contacts" /* ShareContacts */]: false,
+  ["request-permission" /* RequestPermission */]: false,
+  ["get-permissions" /* GetPermissions */]: false,
+  ["send-haptic-feedback" /* SendHapticFeedback */]: false,
+  ["share" /* Share */]: false,
+  ["chat" /* Chat */]: false
+};
+function isCommandAvailable(command) {
+  return commandAvailability[command];
+}
+function setCommandAvailable(command, available) {
+  commandAvailability[command] = available;
+}
+function validateCommands(worldAppSupportedCommands) {
+  let allCommandsValid = true;
+  Object.entries(COMMAND_VERSIONS).forEach(([commandName, version]) => {
+    const commandInput = worldAppSupportedCommands.find(
+      (cmd) => cmd.name === commandName
+    );
+    let isCommandValid = false;
+    if (!commandInput) {
+      console.warn(
+        `Command ${commandName} is not supported by the app. Try updating the app version`
+      );
+    } else {
+      if (commandInput.supported_versions.includes(version)) {
+        setCommandAvailable(commandName, true);
+        isCommandValid = true;
+      } else {
+        isCommandValid = true;
+        console.warn(
+          `Command ${commandName} version ${version} is not supported by the app. Supported versions: ${commandInput.supported_versions.join(", ")}. This is not an error, but it is recommended to update the World App version.`
+        );
+        setCommandAvailable(commandName, true);
+      }
+    }
+    if (!isCommandValid) {
+      allCommandsValid = false;
+    }
+  });
+  return allCommandsValid;
+}
+function sendMiniKitEvent(payload) {
+  sendWebviewEvent(payload);
+}
+
+// commands/chat.ts
+var ChatErrorCodes = /* @__PURE__ */ ((ChatErrorCodes2) => {
+  ChatErrorCodes2["UserRejected"] = "user_rejected";
+  ChatErrorCodes2["SendFailed"] = "send_failed";
+  ChatErrorCodes2["GenericError"] = "generic_error";
+  return ChatErrorCodes2;
+})(ChatErrorCodes || {});
+var ChatErrorMessage = {
+  ["user_rejected" /* UserRejected */]: "User rejected the request.",
+  ["send_failed" /* SendFailed */]: "Failed to send the message.",
+  ["generic_error" /* GenericError */]: "Something unexpected went wrong."
+};
+function 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;
+  };
+}
+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);
+      }
+    });
+  };
+}
+
+// commands/get-permissions.ts
+var GetPermissionsErrorCodes = /* @__PURE__ */ ((GetPermissionsErrorCodes2) => {
+  GetPermissionsErrorCodes2["GenericError"] = "generic_error";
+  return GetPermissionsErrorCodes2;
+})(GetPermissionsErrorCodes || {});
+var GetPermissionsErrorMessage = {
+  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again."
+};
+var Permission = /* @__PURE__ */ ((Permission2) => {
+  Permission2["Notifications"] = "notifications";
+  Permission2["Contacts"] = "contacts";
+  Permission2["Microphone"] = "microphone";
+  return Permission2;
+})(Permission || {});
+function createGetPermissionsCommand(_ctx) {
+  return () => {
+    if (typeof window === "undefined" || !isCommandAvailable("get-permissions" /* GetPermissions */)) {
+      console.error(
+        "'getPermissions' command is unavailable. Check MiniKit.install() or update the app version"
+      );
+      return null;
+    }
+    sendMiniKitEvent({
+      command: "get-permissions" /* GetPermissions */,
+      version: COMMAND_VERSIONS["get-permissions" /* GetPermissions */],
+      payload: {}
+    });
+    return {
+      status: "sent"
+    };
+  };
+}
+function createGetPermissionsAsyncCommand(ctx, syncCommand) {
+  return async () => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (payload) => {
+          ctx.events.unsubscribe("miniapp-get-permissions" /* MiniAppGetPermissions */);
+          resolve({ commandPayload, finalPayload: payload });
+        };
+        ctx.events.subscribe(
+          "miniapp-get-permissions" /* MiniAppGetPermissions */,
+          handleResponse
+        );
+        commandPayload = syncCommand();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// types/payment.ts
+var Tokens = /* @__PURE__ */ ((Tokens3) => {
+  Tokens3["USDC"] = "USDCE";
+  Tokens3["WLD"] = "WLD";
+  return Tokens3;
+})(Tokens || {});
+var TokenDecimals = {
+  ["USDCE" /* USDC */]: 6,
+  ["WLD" /* WLD */]: 18
+};
+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;
+};
+var validatePaymentPayload = (payload) => {
+  if (payload.tokens.some(
+    (token) => token.symbol == "USDCE" /* USDC */ && parseFloat(token.token_amount) < 0.1
+  )) {
+    console.error("USDC amount should be greater than $0.1");
+    return false;
+  }
+  if (payload.reference.length > 36) {
+    console.error("Reference must not exceed 36 characters");
+    return false;
+  }
+  if (typeof payload.reference !== "string") {
+    throw new Error("Reference must be a string");
+  }
+  return true;
 };
+
+// commands/pay.ts
 var PaymentErrorCodes = /* @__PURE__ */ ((PaymentErrorCodes2) => {
   PaymentErrorCodes2["InputError"] = "input_error";
   PaymentErrorCodes2["UserRejected"] = "user_rejected";
@@ -117,135 +373,106 @@ var PaymentErrorMessage = {
   ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again.",
   ["user_blocked" /* UserBlocked */]: "User's region is blocked from making payments."
 };
-var PaymentValidationErrors = /* @__PURE__ */ ((PaymentValidationErrors2) => {
-  PaymentValidationErrors2["MalformedRequest"] = "There was a problem with this request. Please try again or contact the app owner.";
-  PaymentValidationErrors2["InvalidTokenAddress"] = "The token address is invalid. Please contact the app owner.";
-  PaymentValidationErrors2["InvalidAppId"] = "The app ID is invalid. Please contact the app owner.";
-  PaymentValidationErrors2["DuplicateReference"] = "This reference ID already exists please generate a new one and try again.";
-  return PaymentValidationErrors2;
-})(PaymentValidationErrors || {});
-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."
-};
-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."
-};
-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."
-};
-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."
-};
-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."
-};
-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."
-};
-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"
-};
-var GetPermissionsErrorCodes = /* @__PURE__ */ ((GetPermissionsErrorCodes2) => {
-  GetPermissionsErrorCodes2["GenericError"] = "generic_error";
-  return GetPermissionsErrorCodes2;
-})(GetPermissionsErrorCodes || {});
-var GetPermissionsErrorMessage = {
-  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again."
+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;
+  };
+}
+function createPayAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (response) => {
+          ctx.events.unsubscribe("miniapp-payment" /* MiniAppPayment */);
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-payment" /* MiniAppPayment */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// 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"
 };
+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;
+  };
+}
+function createRequestPermissionAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (response) => {
+          ctx.events.unsubscribe("miniapp-request-permission" /* MiniAppRequestPermission */);
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-request-permission" /* MiniAppRequestPermission */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// commands/send-haptic-feedback.ts
 var SendHapticFeedbackErrorCodes = /* @__PURE__ */ ((SendHapticFeedbackErrorCodes2) => {
   SendHapticFeedbackErrorCodes2["GenericError"] = "generic_error";
   SendHapticFeedbackErrorCodes2["UserRejected"] = "user_rejected";
@@ -255,235 +482,177 @@ var SendHapticFeedbackErrorMessage = {
   ["generic_error" /* GenericError */]: "Something unexpected went wrong.",
   ["user_rejected" /* UserRejected */]: "User rejected the request."
 };
-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"
-};
-var MicrophoneErrorCodes = /* @__PURE__ */ ((MicrophoneErrorCodes2) => {
-  MicrophoneErrorCodes2["MiniAppPermissionNotEnabled"] = "mini_app_permission_not_enabled";
-  MicrophoneErrorCodes2["WorldAppPermissionNotEnabled"] = "world_app_permission_not_enabled";
-  return MicrophoneErrorCodes2;
-})(MicrophoneErrorCodes || {});
-var MicrophoneErrorMessage = {
-  ["mini_app_permission_not_enabled" /* MiniAppPermissionNotEnabled */]: "Microphone permission not enabled for your Mini App",
-  ["world_app_permission_not_enabled" /* WorldAppPermissionNotEnabled */]: "Microphone permission not enabled in World App"
-};
-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."
-};
-
-// types/responses.ts
-var ResponseEvent = /* @__PURE__ */ ((ResponseEvent2) => {
-  ResponseEvent2["MiniAppVerifyAction"] = "miniapp-verify-action";
-  ResponseEvent2["MiniAppPayment"] = "miniapp-payment";
-  ResponseEvent2["MiniAppWalletAuth"] = "miniapp-wallet-auth";
-  ResponseEvent2["MiniAppSendTransaction"] = "miniapp-send-transaction";
-  ResponseEvent2["MiniAppSignMessage"] = "miniapp-sign-message";
-  ResponseEvent2["MiniAppSignTypedData"] = "miniapp-sign-typed-data";
-  ResponseEvent2["MiniAppShareContacts"] = "miniapp-share-contacts";
-  ResponseEvent2["MiniAppRequestPermission"] = "miniapp-request-permission";
-  ResponseEvent2["MiniAppGetPermissions"] = "miniapp-get-permissions";
-  ResponseEvent2["MiniAppSendHapticFeedback"] = "miniapp-send-haptic-feedback";
-  ResponseEvent2["MiniAppShare"] = "miniapp-share";
-  ResponseEvent2["MiniAppMicrophone"] = "miniapp-microphone";
-  ResponseEvent2["MiniAppChat"] = "miniapp-chat";
-  return ResponseEvent2;
-})(ResponseEvent || {});
-
-// helpers/microphone/index.ts
-var microphoneSetupDone = false;
-var setupMicrophone = () => {
-  if (microphoneSetupDone) {
-    return;
-  }
-  if (typeof navigator !== "undefined" && !navigator.mediaDevices?.getUserMedia)
-    return;
-  const originalStop = MediaStreamTrack.prototype.stop;
-  MediaStreamTrack.prototype.stop = function() {
-    originalStop.call(this);
-    if (this.readyState === "ended") {
-      setTimeout(() => this.dispatchEvent(new Event("ended")), 0);
+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;
   };
-  const realGUM = navigator.mediaDevices.getUserMedia.bind(
-    navigator.mediaDevices
-  );
-  const live = /* @__PURE__ */ new Set();
-  async function wrapped(constraints) {
-    const stream = await realGUM(constraints);
-    const hasAudioTrack = stream.getAudioTracks().length > 0;
-    if (hasAudioTrack) {
-      sendWebviewEvent({
-        command: "microphone-stream-started",
-        version: 1,
-        payload: {
-          streamId: stream.id
-        }
-      });
-      live.add(stream);
-      stream.getAudioTracks().forEach((t) => {
-        t.addEventListener("ended", () => {
-          const allAudioTracksEnded = stream.getAudioTracks().every((track) => track.readyState === "ended");
-          if (allAudioTracksEnded) {
-            sendWebviewEvent({
-              command: "microphone-stream-ended",
-              version: 1,
-              payload: {
-                streamId: stream.id
-              }
-            });
-            live.delete(stream);
-          }
-        });
-      });
-    }
-    return stream;
-  }
-  Object.defineProperty(navigator.mediaDevices, "getUserMedia", {
-    value: wrapped,
-    writable: false,
-    configurable: false,
-    enumerable: true
-  });
-  Object.freeze(navigator.mediaDevices);
-  const stopAllMiniAppMicrophoneStreams = () => {
-    live.forEach((s) => {
-      const audioTracks = s.getAudioTracks();
-      if (audioTracks.length > 0) {
-        audioTracks.forEach((t) => {
-          t.stop();
-        });
-        sendWebviewEvent({
-          command: "microphone-stream-ended",
-          version: 1,
-          payload: {
-            streamId: s.id
-          }
-        });
+}
+function createSendHapticFeedbackAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (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);
       }
     });
-    live.clear();
   };
-  MiniKit.subscribe("miniapp-microphone" /* MiniAppMicrophone */, (payload) => {
-    if (payload.status === "error" && (payload.error_code === "mini_app_permission_not_enabled" /* MiniAppPermissionNotEnabled */ || payload.error_code === "world_app_permission_not_enabled" /* WorldAppPermissionNotEnabled */)) {
-      console.log("stopping all microphone streams", payload);
-      stopAllMiniAppMicrophoneStreams();
-    }
-  });
-  window.__stopAllMiniAppMicrophoneStreams = stopAllMiniAppMicrophoneStreams;
-  microphoneSetupDone = true;
-};
+}
 
-// types/payment.ts
-var Tokens = /* @__PURE__ */ ((Tokens2) => {
-  Tokens2["USDC"] = "USDCE";
-  Tokens2["WLD"] = "WLD";
-  return Tokens2;
-})(Tokens || {});
-var TokenDecimals = {
-  ["USDCE" /* USDC */]: 6,
-  ["WLD" /* WLD */]: 18
+// helpers/transaction/validate-payload.ts
+var isValidHex = (str) => {
+  return /^0x[0-9A-Fa-f]+$/.test(str);
 };
-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}`);
+var objectValuesToArrayRecursive = (input) => {
+  if (input === null || typeof input !== "object") {
+    return input;
   }
-  const factor = 10 ** decimals;
-  const result = amount * factor;
-  if (!Number.isInteger(result)) {
-    throw new Error(`The resulting amount is not a whole number: ${result}`);
+  if (Array.isArray(input)) {
+    return input.map((item) => objectValuesToArrayRecursive(item));
   }
-  return result;
+  const values = Object.values(input);
+  return values.map((value) => objectValuesToArrayRecursive(value));
 };
-var validatePaymentPayload = (payload) => {
-  if (payload.tokens.some(
-    (token) => token.symbol == "USDCE" /* USDC */ && parseFloat(token.token_amount) < 0.1
-  )) {
-    console.error("USDC amount should be greater than $0.1");
-    return false;
+var processPayload = (payload) => {
+  if (typeof payload === "boolean" || typeof payload === "string" || payload === null || payload === void 0) {
+    return payload;
   }
-  if (payload.reference.length > 36) {
-    console.error("Reference must not exceed 36 characters");
-    return false;
+  if (typeof payload === "number" || typeof payload === "bigint") {
+    return String(payload);
   }
-  if (typeof payload.reference !== "string") {
-    throw new Error("Reference must be a string");
+  if (Array.isArray(payload)) {
+    return payload.map((value) => processPayload(value));
   }
-  return true;
-};
-
-// helpers/proof/index.ts
-var import_viem = require("viem");
-var import_chains = require("viem/chains");
-var semaphoreVerifierAddress = "0x79f46b94d134109EbcbbddBAeD0E88790409A0e4";
-var semaphoreVerifierAbi = [
-  {
-    inputs: [
-      {
-        internalType: "uint256[8]",
-        name: "proof",
-        type: "uint256[8]"
+  if (typeof payload === "object") {
+    const result = { ...payload };
+    if ("value" in result && result.value !== void 0) {
+      if (typeof result.value !== "string") {
+        result.value = String(result.value);
       }
-    ],
-    name: "compressProof",
-    outputs: [
-      {
-        internalType: "uint256[4]",
-        name: "compressed",
-        type: "uint256[4]"
+      if (!isValidHex(result.value)) {
+        console.error(
+          "Transaction value must be a valid hex string",
+          result.value
+        );
+        throw new Error(
+          `Transaction value must be a valid hex string: ${result.value}`
+        );
       }
-    ],
-    stateMutability: "view",
-    type: "function"
+    }
+    for (const key in result) {
+      if (Object.prototype.hasOwnProperty.call(result, key)) {
+        result[key] = processPayload(result[key]);
+      }
+    }
+    return result;
   }
-];
-var compressAndPadProof = async (proof, rpcUrl) => {
-  try {
-    const publicClient = (0, import_viem.createPublicClient)({
-      chain: import_chains.worldchain,
-      transport: (0, import_viem.http)(
-        rpcUrl || "https://worldchain-mainnet.g.alchemy.com/public"
-      )
-    });
-    const decodedProof = (0, import_viem.decodeAbiParameters)(
-      [{ type: "uint256[8]" }],
-      proof
-    )[0];
-    const compressedProof = await publicClient.readContract({
-      address: semaphoreVerifierAddress,
-      abi: semaphoreVerifierAbi,
-      functionName: "compressProof",
-      args: [decodedProof]
+  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
+      };
     });
-    const paddedProof = [...compressedProof, 0n, 0n, 0n, 0n];
-    return (0, import_viem.encodeAbiParameters)([{ type: "uint256[8]" }], [paddedProof]);
-  } catch (e) {
-    return proof;
+    return formattedPayload;
   }
+  return payload;
+};
+
+// commands/send-transaction.ts
+var SendTransactionErrorCodes = /* @__PURE__ */ ((SendTransactionErrorCodes2) => {
+  SendTransactionErrorCodes2["InvalidOperation"] = "invalid_operation";
+  SendTransactionErrorCodes2["UserRejected"] = "user_rejected";
+  SendTransactionErrorCodes2["InputError"] = "input_error";
+  SendTransactionErrorCodes2["SimulationFailed"] = "simulation_failed";
+  SendTransactionErrorCodes2["TransactionFailed"] = "transaction_failed";
+  SendTransactionErrorCodes2["GenericError"] = "generic_error";
+  SendTransactionErrorCodes2["DisallowedOperation"] = "disallowed_operation";
+  SendTransactionErrorCodes2["ValidationError"] = "validation_error";
+  SendTransactionErrorCodes2["InvalidContract"] = "invalid_contract";
+  SendTransactionErrorCodes2["MaliciousOperation"] = "malicious_operation";
+  SendTransactionErrorCodes2["DailyTxLimitReached"] = "daily_tx_limit_reached";
+  SendTransactionErrorCodes2["PermittedAmountExceedsSlippage"] = "permitted_amount_exceeds_slippage";
+  SendTransactionErrorCodes2["PermittedAmountNotFound"] = "permitted_amount_not_found";
+  return SendTransactionErrorCodes2;
+})(SendTransactionErrorCodes || {});
+var SendTransactionErrorMessage = {
+  ["invalid_operation" /* InvalidOperation */]: "Transaction included an operation that was invalid",
+  ["user_rejected" /* UserRejected */]: "User rejected the request.",
+  ["input_error" /* InputError */]: "Invalid payload.",
+  ["simulation_failed" /* SimulationFailed */]: "The transaction simulation failed.",
+  ["validation_error" /* ValidationError */]: "The transaction validation failed. Please try again.",
+  ["transaction_failed" /* TransactionFailed */]: "The transaction failed. Please try again later.",
+  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again.",
+  ["disallowed_operation" /* DisallowedOperation */]: "The operation requested is not allowed. Please refer to the docs.",
+  ["invalid_contract" /* InvalidContract */]: "The contract address is not allowed for your application. Please check your developer portal configurations",
+  ["malicious_operation" /* MaliciousOperation */]: "The operation requested is considered malicious.",
+  ["daily_tx_limit_reached" /* DailyTxLimitReached */]: "Daily transaction limit reached. Max 100 transactions per day. Wait until the next day.",
+  ["permitted_amount_exceeds_slippage" /* PermittedAmountExceedsSlippage */]: "Permitted amount exceeds slippage. You must spend at least 90% of the permitted amount.",
+  ["permitted_amount_not_found" /* PermittedAmountNotFound */]: "Permitted amount not found in permit2 payload."
 };
+function createSendTransactionCommand(_ctx) {
+  return (payload) => {
+    if (typeof window === "undefined" || !isCommandAvailable("send-transaction" /* SendTransaction */)) {
+      console.error(
+        "'sendTransaction' command is unavailable. Check MiniKit.install() or update the app version"
+      );
+      return null;
+    }
+    payload.formatPayload = payload.formatPayload !== false;
+    const validatedPayload = validateSendTransactionPayload(payload);
+    sendMiniKitEvent({
+      command: "send-transaction" /* SendTransaction */,
+      version: COMMAND_VERSIONS["send-transaction" /* SendTransaction */],
+      payload: validatedPayload
+    });
+    return validatedPayload;
+  };
+}
+function createSendTransactionAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (response) => {
+          ctx.events.unsubscribe("miniapp-send-transaction" /* MiniAppSendTransaction */);
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-send-transaction" /* MiniAppSendTransaction */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
 
 // helpers/share/index.ts
 var MAX_FILES = 10;
@@ -551,115 +720,387 @@ var formatShareInput = async (input) => {
   };
 };
 
-// helpers/siwe/siwe.ts
-var import_viem2 = require("viem");
-var import_chains2 = 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}'`);
-  }
+// 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"
 };
-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);
+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 (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;
+    if (ctx.state.deviceProperties.deviceOS === "ios" && typeof navigator !== "undefined") {
+      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);
+      });
+    }
+    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);
+      }
+    });
+  };
+}
+
+// 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."
+};
+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;
+  };
+}
+function createShareContactsAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (response) => {
+          ctx.events.unsubscribe("miniapp-share-contacts" /* MiniAppShareContacts */);
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-share-contacts" /* MiniAppShareContacts */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// 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."
+};
+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;
+  };
+}
+function createSignMessageAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (response) => {
+          ctx.events.unsubscribe("miniapp-sign-message" /* MiniAppSignMessage */);
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-sign-message" /* MiniAppSignMessage */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// 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."
+};
+function createSignTypedDataCommand(_ctx) {
+  return (payload) => {
+    if (typeof window === "undefined" || !isCommandAvailable("sign-typed-data" /* SignTypedData */)) {
+      console.error(
+        "'signTypedData' command is unavailable. Check MiniKit.install() or update the app version"
+      );
+      return null;
+    }
+    if (!payload.chainId) {
+      payload.chainId = 480;
+    }
+    sendMiniKitEvent({
+      command: "sign-typed-data" /* SignTypedData */,
+      version: COMMAND_VERSIONS["sign-typed-data" /* SignTypedData */],
+      payload
+    });
+    return payload;
+  };
+}
+function createSignTypedDataAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (response) => {
+          ctx.events.unsubscribe("miniapp-sign-typed-data" /* MiniAppSignTypedData */);
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-sign-typed-data" /* MiniAppSignTypedData */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// commands/verify.ts
+var import_idkit_core = require("@worldcoin/idkit-core");
+var import_hashing = require("@worldcoin/idkit-core/hashing");
+var import_idkit_core2 = require("@worldcoin/idkit-core");
+function createVerifyCommand(_ctx) {
+  return (payload) => {
+    if (typeof window === "undefined" || !isCommandAvailable("verify" /* Verify */)) {
+      console.error(
+        "'verify' command is unavailable. Check MiniKit.install() or update the app version"
+      );
+      return null;
+    }
+    if (Array.isArray(payload.verification_level) && payload.verification_level.length === 0) {
+      console.error("'verification_level' must not be an empty array");
+      return null;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const eventPayload = {
+      action: (0, import_hashing.encodeAction)(payload.action),
+      signal: (0, import_hashing.generateSignal)(payload.signal).digest,
+      verification_level: payload.verification_level || import_idkit_core.VerificationLevel.Orb,
+      timestamp
+    };
+    sendMiniKitEvent({
+      command: "verify" /* Verify */,
+      version: COMMAND_VERSIONS["verify" /* Verify */],
+      payload: eventPayload
+    });
+    return eventPayload;
+  };
+}
+function createVerifyAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = (response) => {
+          ctx.events.unsubscribe("miniapp-verify-action" /* MiniAppVerifyAction */);
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-verify-action" /* MiniAppVerifyAction */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// helpers/siwe/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 = "";
@@ -762,16 +1203,16 @@ var verifySiweMessageV1 = async (payload, nonce, statement, requestId, userProvi
   const { message, signature, address } = payload;
   const siweMessageData = parseSiweMessage(message);
   validateMessage(siweMessageData, nonce, statement, requestId);
-  let provider = userProvider || (0, import_viem2.createPublicClient)({ chain: import_chains2.worldchain, transport: (0, import_viem2.http)() });
+  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_viem2.hashMessage)(signedMessage);
-  const contract = (0, import_viem2.getContract)({
+  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_viem2.recoverAddress)({
+    const recoveredAddress = await (0, import_viem.recoverAddress)({
       hash: hashedMessage,
       signature: `0x${signature}`
     });
@@ -794,12 +1235,12 @@ var verifySiweMessageV2 = async (payload, nonce, statement, requestId, userProvi
     throw new Error("Validation failed");
   }
   try {
-    const walletContract = (0, import_viem2.getContract)({
+    const walletContract = (0, import_viem.getContract)({
       address,
       abi: SAFE_CONTRACT_ABI,
-      client: userProvider || (0, import_viem2.createPublicClient)({ chain: import_chains2.worldchain, transport: (0, import_viem2.http)() })
+      client: userProvider || (0, import_viem.createPublicClient)({ chain: import_chains.worldchain, transport: (0, import_viem.http)() })
     });
-    const hashedMessage = (0, import_viem2.hashMessage)(message);
+    const hashedMessage = (0, import_viem.hashMessage)(message);
     const res = await walletContract.read.isValidSignature([
       hashedMessage,
       signature
@@ -834,71 +1275,294 @@ var validateWalletAuthCommandInput = (params) => {
   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 };
+  return { valid: true };
+};
+
+// commands/wallet-auth.ts
+var WalletAuthErrorCodes = /* @__PURE__ */ ((WalletAuthErrorCodes2) => {
+  WalletAuthErrorCodes2["MalformedRequest"] = "malformed_request";
+  WalletAuthErrorCodes2["UserRejected"] = "user_rejected";
+  WalletAuthErrorCodes2["GenericError"] = "generic_error";
+  return WalletAuthErrorCodes2;
+})(WalletAuthErrorCodes || {});
+var WalletAuthErrorMessage = {
+  ["malformed_request" /* MalformedRequest */]: "Provided parameters in the request are invalid.",
+  ["user_rejected" /* UserRejected */]: "User rejected the request.",
+  ["generic_error" /* GenericError */]: "Something unexpected went wrong."
+};
+function createWalletAuthCommand(ctx) {
+  return (payload) => {
+    if (typeof window === "undefined" || !isCommandAvailable("wallet-auth" /* WalletAuth */)) {
+      console.error(
+        "'walletAuth' command is unavailable. Check MiniKit.install() or update the app version"
+      );
+      return null;
+    }
+    const validationResult = validateWalletAuthCommandInput(payload);
+    if (!validationResult.valid) {
+      console.error(
+        "Failed to validate wallet auth input:\n\n -->",
+        validationResult.message
+      );
+      return null;
+    }
+    let protocol = null;
+    try {
+      const currentUrl = new URL(window.location.href);
+      protocol = currentUrl.protocol.split(":")[0];
+    } catch (error) {
+      console.error("Failed to get current URL", error);
+      return null;
+    }
+    const siweMessage = generateSiweMessage({
+      scheme: protocol,
+      domain: window.location.host,
+      statement: payload.statement ?? void 0,
+      uri: window.location.href,
+      version: "1",
+      chain_id: 480,
+      nonce: payload.nonce,
+      issued_at: (/* @__PURE__ */ new Date()).toISOString(),
+      expiration_time: payload.expirationTime?.toISOString() ?? void 0,
+      not_before: payload.notBefore?.toISOString() ?? void 0,
+      request_id: payload.requestId ?? void 0
+    });
+    const walletAuthPayload = { siweMessage };
+    const walletAuthVersion = ctx.state.user.worldAppVersion && ctx.state.user.worldAppVersion > 2087900 ? COMMAND_VERSIONS["wallet-auth" /* WalletAuth */] : 1;
+    sendMiniKitEvent({
+      command: "wallet-auth" /* WalletAuth */,
+      version: walletAuthVersion,
+      payload: walletAuthPayload
+    });
+    return walletAuthPayload;
+  };
+}
+function createWalletAuthAsyncCommand(ctx, syncCommand) {
+  return async (payload) => {
+    return new Promise((resolve, reject) => {
+      try {
+        let commandPayload = null;
+        const handleResponse = async (response) => {
+          ctx.events.unsubscribe("miniapp-wallet-auth" /* MiniAppWalletAuth */);
+          if (response.status === "success") {
+            await ctx.state.updateUserFromWalletAuth(response.address);
+          }
+          resolve({ commandPayload, finalPayload: response });
+        };
+        ctx.events.subscribe(
+          "miniapp-wallet-auth" /* MiniAppWalletAuth */,
+          handleResponse
+        );
+        commandPayload = syncCommand(payload);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+// commands/index.ts
+function createCommands(ctx) {
+  return {
+    verify: createVerifyCommand(ctx),
+    pay: createPayCommand(ctx),
+    walletAuth: createWalletAuthCommand(ctx),
+    sendTransaction: createSendTransactionCommand(ctx),
+    signMessage: createSignMessageCommand(ctx),
+    signTypedData: createSignTypedDataCommand(ctx),
+    shareContacts: createShareContactsCommand(ctx),
+    requestPermission: createRequestPermissionCommand(ctx),
+    getPermissions: createGetPermissionsCommand(ctx),
+    sendHapticFeedback: createSendHapticFeedbackCommand(ctx),
+    share: createShareCommand(ctx),
+    chat: createChatCommand(ctx)
+  };
+}
+function createAsyncCommands(ctx, commands) {
+  return {
+    verify: createVerifyAsyncCommand(ctx, commands.verify),
+    pay: createPayAsyncCommand(ctx, commands.pay),
+    walletAuth: createWalletAuthAsyncCommand(ctx, commands.walletAuth),
+    sendTransaction: createSendTransactionAsyncCommand(
+      ctx,
+      commands.sendTransaction
+    ),
+    signMessage: createSignMessageAsyncCommand(ctx, commands.signMessage),
+    signTypedData: createSignTypedDataAsyncCommand(ctx, commands.signTypedData),
+    shareContacts: createShareContactsAsyncCommand(ctx, commands.shareContacts),
+    requestPermission: createRequestPermissionAsyncCommand(
+      ctx,
+      commands.requestPermission
+    ),
+    getPermissions: createGetPermissionsAsyncCommand(
+      ctx,
+      commands.getPermissions
+    ),
+    sendHapticFeedback: createSendHapticFeedbackAsyncCommand(
+      ctx,
+      commands.sendHapticFeedback
+    ),
+    share: createShareAsyncCommand(ctx, commands.share),
+    chat: createChatAsyncCommand(ctx, commands.chat)
+  };
+}
+
+// core/events.ts
+var import_idkit_core3 = require("@worldcoin/idkit-core");
+
+// helpers/proof/index.ts
+var import_viem2 = require("viem");
+var import_chains2 = require("viem/chains");
+var semaphoreVerifierAddress = "0x79f46b94d134109EbcbbddBAeD0E88790409A0e4";
+var semaphoreVerifierAbi = [
+  {
+    inputs: [
+      {
+        internalType: "uint256[8]",
+        name: "proof",
+        type: "uint256[8]"
+      }
+    ],
+    name: "compressProof",
+    outputs: [
+      {
+        internalType: "uint256[4]",
+        name: "compressed",
+        type: "uint256[4]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var compressAndPadProof = async (proof, rpcUrl) => {
+  try {
+    const publicClient = (0, import_viem2.createPublicClient)({
+      chain: import_chains2.worldchain,
+      transport: (0, import_viem2.http)(
+        rpcUrl || "https://worldchain-mainnet.g.alchemy.com/public"
+      )
+    });
+    const decodedProof = (0, import_viem2.decodeAbiParameters)(
+      [{ type: "uint256[8]" }],
+      proof
+    )[0];
+    const compressedProof = await publicClient.readContract({
+      address: semaphoreVerifierAddress,
+      abi: semaphoreVerifierAbi,
+      functionName: "compressProof",
+      args: [decodedProof]
+    });
+    const paddedProof = [...compressedProof, 0n, 0n, 0n, 0n];
+    return (0, import_viem2.encodeAbiParameters)([{ type: "uint256[8]" }], [paddedProof]);
+  } catch (e) {
+    return proof;
+  }
 };
 
-// helpers/transaction/validate-payload.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));
+// 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 */]: () => {
+      }
+    };
   }
-  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;
+  subscribe(event, handler) {
+    this.listeners[event] = handler;
   }
-  if (typeof payload === "number" || typeof payload === "bigint") {
-    return String(payload);
+  unsubscribe(event) {
+    delete this.listeners[event];
   }
-  if (Array.isArray(payload)) {
-    return payload.map((value) => processPayload(value));
+  trigger(event, payload) {
+    if (!this.listeners[event]) {
+      console.error(
+        `No handler for event ${event}, payload: ${JSON.stringify(payload)}`
+      );
+      return;
+    }
+    if (event === "miniapp-verify-action" /* MiniAppVerifyAction */) {
+      const handler = this.listeners[event];
+      this.unsubscribe(event);
+      this.processVerifyActionPayload(
+        payload,
+        handler
+      );
+      return;
+    }
+    this.listeners[event](payload);
   }
-  if (typeof payload === "object") {
-    const result = { ...payload };
-    if ("value" in result && result.value !== void 0) {
-      if (typeof result.value !== "string") {
-        result.value = String(result.value);
-      }
-      if (!isValidHex(result.value)) {
-        console.error(
-          "Transaction value must be a valid hex string",
-          result.value
+  async processVerifyActionPayload(payload, handler) {
+    if (payload.status === "error" && payload.error_code === "user_rejected") {
+      payload.error_code = import_idkit_core3.AppErrorCodes.VerificationRejected;
+    }
+    if (payload.status === "success") {
+      if ("verifications" in payload) {
+        const orbVerification = payload.verifications.find(
+          (v) => v.verification_level === import_idkit_core3.VerificationLevel.Orb
         );
-        throw new Error(
-          `Transaction value must be a valid hex string: ${result.value}`
+        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
+          }
         );
       }
     }
-    for (const key in result) {
-      if (Object.prototype.hasOwnProperty.call(result, key)) {
-        result[key] = processPayload(result[key]);
-      }
-    }
-    return result;
+    handler(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;
+  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;
+    }
   }
-  return payload;
 };
 
 // helpers/usernames/index.ts
@@ -916,29 +1580,6 @@ var getUserProfile = async (address) => {
   return usernames?.[0] ?? { username: null, profile_picture_url: null };
 };
 
-// types/commands.ts
-var Command = /* @__PURE__ */ ((Command2) => {
-  Command2["Verify"] = "verify";
-  Command2["Pay"] = "pay";
-  Command2["WalletAuth"] = "wallet-auth";
-  Command2["SendTransaction"] = "send-transaction";
-  Command2["SignMessage"] = "sign-message";
-  Command2["SignTypedData"] = "sign-typed-data";
-  Command2["ShareContacts"] = "share-contacts";
-  Command2["RequestPermission"] = "request-permission";
-  Command2["GetPermissions"] = "get-permissions";
-  Command2["SendHapticFeedback"] = "send-haptic-feedback";
-  Command2["Share"] = "share";
-  Command2["Chat"] = "chat";
-  return Command2;
-})(Command || {});
-var Permission = /* @__PURE__ */ ((Permission2) => {
-  Permission2["Notifications"] = "notifications";
-  Permission2["Contacts"] = "contacts";
-  Permission2["Microphone"] = "microphone";
-  return Permission2;
-})(Permission || {});
-
 // types/init.ts
 var MiniAppLaunchLocation = /* @__PURE__ */ ((MiniAppLaunchLocation3) => {
   MiniAppLaunchLocation3["Chat"] = "chat";
@@ -965,733 +1606,366 @@ var mapWorldAppLaunchLocation = (location) => {
   return WORLD_APP_LAUNCH_LOCATION_MAP[normalizedLocation] ?? null;
 };
 
-// minikit.ts
-var sendMiniKitEvent = (payload) => {
-  sendWebviewEvent(payload);
+// core/state.ts
+var MiniKitState = class {
+  constructor() {
+    this.appId = null;
+    this.user = {};
+    this.deviceProperties = {};
+    this.location = null;
+    this.isReady = false;
+  }
+  initFromWorldApp(worldApp) {
+    if (!worldApp) return;
+    this.user.optedIntoOptionalAnalytics = worldApp.is_optional_analytics;
+    this.user.deviceOS = worldApp.device_os;
+    this.user.worldAppVersion = worldApp.world_app_version;
+    this.deviceProperties.safeAreaInsets = worldApp.safe_area_insets;
+    this.deviceProperties.deviceOS = worldApp.device_os;
+    this.deviceProperties.worldAppVersion = worldApp.world_app_version;
+    this.location = mapWorldAppLaunchLocation(worldApp.location);
+  }
+  async updateUserFromWalletAuth(address) {
+    this.user.walletAddress = address;
+    try {
+      const userProfile = await getUserProfile(address);
+      this.user.username = userProfile.username;
+      this.user.profilePictureUrl = userProfile.profile_picture_url;
+    } catch (error) {
+      console.error("Failed to fetch user profile:", error);
+    }
+  }
+  async getUserByAddress(address) {
+    const walletAddress = address ?? this.user.walletAddress;
+    const userProfile = await getUserProfile(walletAddress);
+    return {
+      walletAddress,
+      username: userProfile.username,
+      profilePictureUrl: userProfile.profile_picture_url
+    };
+  }
+  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
+    };
+  }
 };
-var _MiniKit = class _MiniKit {
-  static sendInit() {
-    sendWebviewEvent({
-      command: "init",
-      payload: {
-        version: this.MINIKIT_VERSION,
-        minorVersion: this.MINIKIT_MINOR_VERSION
+
+// 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."
+};
+
+// helpers/microphone/index.ts
+var microphoneSetupDone = false;
+var setupMicrophone = () => {
+  if (microphoneSetupDone) {
+    return;
+  }
+  if (typeof navigator !== "undefined" && !navigator.mediaDevices?.getUserMedia)
+    return;
+  const originalStop = MediaStreamTrack.prototype.stop;
+  MediaStreamTrack.prototype.stop = function() {
+    originalStop.call(this);
+    if (this.readyState === "ended") {
+      setTimeout(() => this.dispatchEvent(new Event("ended")), 0);
+    }
+  };
+  const realGUM = navigator.mediaDevices.getUserMedia.bind(
+    navigator.mediaDevices
+  );
+  const live = /* @__PURE__ */ new Set();
+  async function wrapped(constraints) {
+    const stream = await realGUM(constraints);
+    const hasAudioTrack = stream.getAudioTracks().length > 0;
+    if (hasAudioTrack) {
+      sendWebviewEvent({
+        command: "microphone-stream-started",
+        version: 1,
+        payload: {
+          streamId: stream.id
+        }
+      });
+      live.add(stream);
+      stream.getAudioTracks().forEach((t) => {
+        t.addEventListener("ended", () => {
+          const allAudioTracksEnded = stream.getAudioTracks().every((track) => track.readyState === "ended");
+          if (allAudioTracksEnded) {
+            sendWebviewEvent({
+              command: "microphone-stream-ended",
+              version: 1,
+              payload: {
+                streamId: stream.id
+              }
+            });
+            live.delete(stream);
+          }
+        });
+      });
+    }
+    return stream;
+  }
+  Object.defineProperty(navigator.mediaDevices, "getUserMedia", {
+    value: wrapped,
+    writable: false,
+    configurable: false,
+    enumerable: true
+  });
+  Object.freeze(navigator.mediaDevices);
+  const stopAllMiniAppMicrophoneStreams = () => {
+    live.forEach((s) => {
+      const audioTracks = s.getAudioTracks();
+      if (audioTracks.length > 0) {
+        audioTracks.forEach((t) => {
+          t.stop();
+        });
+        sendWebviewEvent({
+          command: "microphone-stream-ended",
+          version: 1,
+          payload: {
+            streamId: s.id
+          }
+        });
       }
     });
+    live.clear();
+  };
+  MiniKit.subscribe("miniapp-microphone" /* MiniAppMicrophone */, (payload) => {
+    if (payload.status === "error" && (payload.error_code === "mini_app_permission_not_enabled" /* MiniAppPermissionNotEnabled */ || payload.error_code === "world_app_permission_not_enabled" /* WorldAppPermissionNotEnabled */)) {
+      console.log("stopping all microphone streams", payload);
+      stopAllMiniAppMicrophoneStreams();
+    }
+  });
+  window.__stopAllMiniAppMicrophoneStreams = stopAllMiniAppMicrophoneStreams;
+  microphoneSetupDone = true;
+};
+
+// minikit.ts
+var MINIKIT_VERSION = 1;
+var MINIKIT_MINOR_VERSION = 96;
+var _MiniKit = class _MiniKit {
+  // ============================================================================
+  // Public State Accessors
+  // ============================================================================
+  static get appId() {
+    return this.stateManager.appId;
+  }
+  static set appId(value) {
+    this.stateManager.appId = value;
+  }
+  static get user() {
+    return this.stateManager.user;
+  }
+  static set user(value) {
+    this.stateManager.user = value;
+  }
+  static get deviceProperties() {
+    return this.stateManager.deviceProperties;
+  }
+  static get location() {
+    return this.stateManager.location;
   }
+  // ============================================================================
+  // Event System
+  // ============================================================================
   static subscribe(event, handler) {
     if (event === "miniapp-wallet-auth" /* MiniAppWalletAuth */) {
       const originalHandler = handler;
       const wrappedHandler = async (payload) => {
         if (payload.status === "success") {
-          _MiniKit.user.walletAddress = payload.address;
-          try {
-            const user = await _MiniKit.getUserByAddress(payload.address);
-            _MiniKit.user = { ..._MiniKit.user, ...user };
-          } catch (error) {
-            console.error("Failed to fetch user profile:", error);
-          }
+          await this.stateManager.updateUserFromWalletAuth(payload.address);
         }
         originalHandler(payload);
       };
-      this.listeners[event] = wrappedHandler;
-    } else if (event === "miniapp-verify-action" /* MiniAppVerifyAction */) {
-      const originalHandler = handler;
-      const wrappedHandler = (payload) => {
-        if (payload.status === "error" && payload.error_code == "user_rejected") {
-          payload.error_code = import_idkit_core2.AppErrorCodes.VerificationRejected;
-        }
-        if (payload.status === "success" && payload.verification_level === import_idkit_core3.VerificationLevel.Orb) {
-          compressAndPadProof(payload.proof).then(
-            (compressedProof) => {
-              payload.proof = compressedProof;
-              originalHandler(payload);
-            }
-          );
-        } else {
-          originalHandler(payload);
-        }
-      };
-      this.listeners[event] = wrappedHandler;
+      this.eventManager.subscribe(event, wrappedHandler);
     } else {
-      this.listeners[event] = handler;
+      this.eventManager.subscribe(event, handler);
     }
   }
   static unsubscribe(event) {
-    delete this.listeners[event];
+    this.eventManager.unsubscribe(event);
   }
   static trigger(event, payload) {
-    if (!this.listeners[event]) {
-      console.error(
-        `No handler for event ${event}, payload: ${JSON.stringify(payload)}`
-      );
-      return;
-    }
-    this.listeners[event](payload);
-  }
-  static async awaitCommand(event, command, executor) {
-    return new Promise((resolve) => {
-      let commandPayload = null;
-      const handleAndUnsubscribe = (payload) => {
-        this.unsubscribe(event);
-        resolve({ commandPayload, finalPayload: payload });
-      };
-      this.subscribe(event, handleAndUnsubscribe);
-      commandPayload = executor();
-    });
-  }
-  static commandsValid(worldAppSupportedCommands) {
-    let allCommandsValid = true;
-    Object.entries(this.miniKitCommandVersion).forEach(
-      ([minikitCommandName, version]) => {
-        const commandInput = worldAppSupportedCommands.find(
-          (command) => command.name === minikitCommandName
-        );
-        let isCommandValid = false;
-        if (!commandInput) {
-          console.warn(
-            `Command ${minikitCommandName} is not supported by the app. Try updating the app version`
-          );
-        } else {
-          if (commandInput.supported_versions.includes(version)) {
-            _MiniKit.isCommandAvailable[minikitCommandName] = true;
-            isCommandValid = true;
-          } else {
-            isCommandValid = true;
-            console.warn(
-              `Command ${minikitCommandName} version ${version} is not supported by the app. Supported versions: ${commandInput.supported_versions.join(", ")}. This is not an error, but it is recommended to update the World App version.`
-            );
-            _MiniKit.isCommandAvailable[minikitCommandName] = isCommandValid;
-          }
-        }
-        if (!isCommandValid) {
-          allCommandsValid = false;
-        }
-      }
-    );
-    return allCommandsValid;
-  }
-  static install(appId) {
-    if (typeof window === "undefined" || Boolean(window.MiniKit)) {
-      return {
-        success: false,
-        errorCode: "already_installed" /* AlreadyInstalled */,
-        errorMessage: MiniKitInstallErrorMessage["already_installed" /* AlreadyInstalled */]
-      };
-    }
-    if (!appId) {
-      console.warn("App ID not provided during install");
-    } else {
-      _MiniKit.appId = appId;
-    }
-    if (!window.WorldApp) {
-      return {
-        success: false,
-        errorCode: "outside_of_worldapp" /* OutsideOfWorldApp */,
-        errorMessage: MiniKitInstallErrorMessage["outside_of_worldapp" /* OutsideOfWorldApp */]
-      };
-    }
-    _MiniKit.user.optedIntoOptionalAnalytics = window.WorldApp.is_optional_analytics;
-    _MiniKit.user.deviceOS = window.WorldApp.device_os;
-    _MiniKit.user.worldAppVersion = window.WorldApp.world_app_version;
-    _MiniKit.deviceProperties.safeAreaInsets = window.WorldApp.safe_area_insets;
-    _MiniKit.deviceProperties.deviceOS = window.WorldApp.device_os;
-    _MiniKit.deviceProperties.worldAppVersion = window.WorldApp.world_app_version;
-    _MiniKit.location = mapWorldAppLaunchLocation(window.WorldApp.location);
-    try {
-      window.MiniKit = _MiniKit;
-      this.sendInit();
-    } catch (error) {
-      console.error(
-        MiniKitInstallErrorMessage["unknown" /* Unknown */],
-        error
-      );
-      return {
-        success: false,
-        errorCode: "unknown" /* Unknown */,
-        errorMessage: MiniKitInstallErrorMessage["unknown" /* Unknown */]
-      };
-    }
-    _MiniKit.isReady = true;
-    setupMicrophone();
-    if (!this.commandsValid(window.WorldApp.supported_commands)) {
-      return {
-        success: false,
-        errorCode: "app_out_of_date" /* AppOutOfDate */,
-        errorMessage: MiniKitInstallErrorMessage["app_out_of_date" /* AppOutOfDate */]
-      };
-    }
-    return { success: true };
-  }
-  static isInstalled(debug) {
-    const isInstalled = _MiniKit.isReady && Boolean(window.MiniKit);
-    if (!isInstalled)
-      console.error(
-        "MiniKit is not installed. Make sure you're running the application inside of World App"
-      );
-    if (debug && isInstalled) console.log("MiniKit is alive!");
-    return isInstalled;
-  }
-};
-_MiniKit.MINIKIT_VERSION = 1;
-_MiniKit.MINIKIT_MINOR_VERSION = 96;
-_MiniKit.miniKitCommandVersion = {
-  ["verify" /* Verify */]: 1,
-  ["pay" /* Pay */]: 1,
-  ["wallet-auth" /* WalletAuth */]: 2,
-  ["send-transaction" /* SendTransaction */]: 1,
-  ["sign-message" /* SignMessage */]: 1,
-  ["sign-typed-data" /* SignTypedData */]: 1,
-  ["share-contacts" /* ShareContacts */]: 1,
-  ["request-permission" /* RequestPermission */]: 1,
-  ["get-permissions" /* GetPermissions */]: 1,
-  ["send-haptic-feedback" /* SendHapticFeedback */]: 1,
-  ["share" /* Share */]: 1,
-  ["chat" /* Chat */]: 1
-};
-_MiniKit.isCommandAvailable = {
-  ["verify" /* Verify */]: false,
-  ["pay" /* Pay */]: false,
-  ["wallet-auth" /* WalletAuth */]: false,
-  ["send-transaction" /* SendTransaction */]: false,
-  ["sign-message" /* SignMessage */]: false,
-  ["sign-typed-data" /* SignTypedData */]: false,
-  ["share-contacts" /* ShareContacts */]: false,
-  ["request-permission" /* RequestPermission */]: false,
-  ["get-permissions" /* GetPermissions */]: false,
-  ["send-haptic-feedback" /* SendHapticFeedback */]: false,
-  ["share" /* Share */]: false,
-  ["chat" /* Chat */]: false
-};
-_MiniKit.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 */]: () => {
+    this.eventManager.trigger(event, payload);
   }
-};
-_MiniKit.appId = null;
-_MiniKit.user = {};
-_MiniKit.deviceProperties = {};
-_MiniKit.location = null;
-_MiniKit.isReady = false;
-_MiniKit.getUserByAddress = async (address) => {
-  const userProfile = await getUserProfile(
-    address ?? _MiniKit.user.walletAddress
-  );
-  return {
-    walletAddress: address ?? _MiniKit.user.walletAddress,
-    username: userProfile.username,
-    profilePictureUrl: userProfile.profile_picture_url
-  };
-};
-_MiniKit.getUserByUsername = async (username) => {
-  const res = await fetch(
-    `https://usernames.worldcoin.org/api/v1/${username}`,
-    {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
+  // ============================================================================
+  // Installation
+  // ============================================================================
+  static sendInit() {
+    sendWebviewEvent({
+      command: "init",
+      payload: {
+        version: MINIKIT_VERSION,
+        minorVersion: MINIKIT_MINOR_VERSION
       }
-    }
-  );
-  const user = await res.json();
-  return {
-    walletAddress: user.address,
-    username: user.username,
-    profilePictureUrl: user.profile_picture_url
-  };
-};
-// This is a helper function for developers to generate MiniApp URLs
-_MiniKit.getMiniAppUrl = (appId, path) => {
-  const baseUrl = new URL("https://world.org/mini-app");
-  baseUrl.searchParams.append("app_id", appId);
-  if (path) {
-    const fullPath = path.startsWith("/") ? path : `/${path}`;
-    baseUrl.searchParams.append("path", encodeURIComponent(fullPath));
-  }
-  return baseUrl.toString();
-};
-// Opens the profile card for a given username or wallet address
-_MiniKit.showProfileCard = (username, walletAddress) => {
-  if (!username && !walletAddress) {
-    console.error(
-      "Either username or walletAddress must be provided to show profile card"
-    );
-    return;
-  }
-  if (username) {
-    window.open(
-      `worldapp://profile?username=${encodeURIComponent(username)}`
-    );
-    return;
-  } else {
-    window.open(
-      `worldapp://profile?address=${encodeURIComponent(walletAddress || "")}`
-    );
-  }
-};
-// Simply re-exporting the existing function
-_MiniKit.getUserInfo = _MiniKit.getUserByAddress;
-_MiniKit.commands = {
-  verify: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["verify" /* Verify */]) {
-      console.error(
-        "'verify' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      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_core3.VerificationLevel.Orb,
-      timestamp
-    };
-    sendMiniKitEvent({
-      command: "verify" /* Verify */,
-      version: _MiniKit.miniKitCommandVersion["verify" /* Verify */],
-      payload: eventPayload
-    });
-    return eventPayload;
-  },
-  pay: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.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: _MiniKit.miniKitCommandVersion["pay" /* Pay */],
-      payload: eventPayload
-    });
-    return eventPayload;
-  },
-  walletAuth: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.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 = _MiniKit.user.worldAppVersion && _MiniKit.user.worldAppVersion > 2087900 ? _MiniKit.miniKitCommandVersion["wallet-auth" /* WalletAuth */] : 1;
-    sendMiniKitEvent({
-      command: "wallet-auth" /* WalletAuth */,
-      version: walletAuthVersion,
-      payload: walletAuthPayload
-    });
-    return walletAuthPayload;
-  },
-  sendTransaction: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.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: _MiniKit.miniKitCommandVersion["send-transaction" /* SendTransaction */],
-      payload: validatedPayload
-    });
-    return validatedPayload;
-  },
-  signMessage: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.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: _MiniKit.miniKitCommandVersion["sign-message" /* SignMessage */],
-      payload
     });
-    return payload;
-  },
-  signTypedData: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["sign-typed-data" /* SignTypedData */]) {
-      console.error(
-        "'signTypedData' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
+  }
+  static install(appId) {
+    if (typeof window === "undefined" || Boolean(window.MiniKit)) {
+      return {
+        success: false,
+        errorCode: "already_installed" /* AlreadyInstalled */,
+        errorMessage: MiniKitInstallErrorMessage["already_installed" /* AlreadyInstalled */]
+      };
     }
-    if (!payload.chainId) {
-      payload.chainId = 480;
+    if (!appId) {
+      console.warn("App ID not provided during install");
+    } else {
+      this.stateManager.appId = appId;
     }
-    sendMiniKitEvent({
-      command: "sign-typed-data" /* SignTypedData */,
-      version: _MiniKit.miniKitCommandVersion["sign-typed-data" /* SignTypedData */],
-      payload
-    });
-    return payload;
-  },
-  shareContacts: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["share-contacts" /* ShareContacts */]) {
-      console.error(
-        "'shareContacts' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
+    if (!window.WorldApp) {
+      return {
+        success: false,
+        errorCode: "outside_of_worldapp" /* OutsideOfWorldApp */,
+        errorMessage: MiniKitInstallErrorMessage["outside_of_worldapp" /* OutsideOfWorldApp */]
+      };
     }
-    sendMiniKitEvent({
-      command: "share-contacts" /* ShareContacts */,
-      version: _MiniKit.miniKitCommandVersion["share-contacts" /* ShareContacts */],
-      payload
-    });
-    return payload;
-  },
-  requestPermission: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["request-permission" /* RequestPermission */]) {
+    this.stateManager.initFromWorldApp(window.WorldApp);
+    try {
+      window.MiniKit = _MiniKit;
+      this.sendInit();
+    } catch (error) {
       console.error(
-        "'requestPermission' command is unavailable. Check MiniKit.install() or update the app version"
+        MiniKitInstallErrorMessage["unknown" /* Unknown */],
+        error
       );
-      return null;
+      return {
+        success: false,
+        errorCode: "unknown" /* Unknown */,
+        errorMessage: MiniKitInstallErrorMessage["unknown" /* Unknown */]
+      };
     }
-    sendMiniKitEvent({
-      command: "request-permission" /* RequestPermission */,
-      version: _MiniKit.miniKitCommandVersion["request-permission" /* RequestPermission */],
-      payload
-    });
-    return payload;
-  },
-  getPermissions: () => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["get-permissions" /* GetPermissions */]) {
-      console.error(
-        "'getPermissions' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
+    this.stateManager.isReady = true;
+    setupMicrophone();
+    if (!validateCommands(window.WorldApp.supported_commands)) {
+      return {
+        success: false,
+        errorCode: "app_out_of_date" /* AppOutOfDate */,
+        errorMessage: MiniKitInstallErrorMessage["app_out_of_date" /* AppOutOfDate */]
+      };
     }
-    sendMiniKitEvent({
-      command: "get-permissions" /* GetPermissions */,
-      version: _MiniKit.miniKitCommandVersion["get-permissions" /* GetPermissions */],
-      payload: {}
-    });
-    return {
-      status: "sent"
-    };
-  },
-  sendHapticFeedback: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["send-haptic-feedback" /* SendHapticFeedback */]) {
+    return { success: true };
+  }
+  static isInstalled(debug) {
+    const isInstalled = this.stateManager.isReady && Boolean(window.MiniKit);
+    if (!isInstalled) {
       console.error(
-        "'sendHapticFeedback' command is unavailable. Check MiniKit.install() or update the app version"
+        "MiniKit is not installed. Make sure you're running the application inside of World App"
       );
-      return null;
     }
-    sendMiniKitEvent({
-      command: "send-haptic-feedback" /* SendHapticFeedback */,
-      version: _MiniKit.miniKitCommandVersion["send-haptic-feedback" /* SendHapticFeedback */],
-      payload
-    });
-    return payload;
-  },
-  // We return share input here because the payload is formatted asynchronously
-  share: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["share" /* Share */]) {
-      console.error(
-        "'share' command is unavailable. Check MiniKit.install() or update the app version"
-      );
-      return null;
+    if (debug && isInstalled) {
+      console.log("MiniKit is alive!");
     }
-    if (_MiniKit.deviceProperties.deviceOS === "ios" && typeof navigator !== "undefined") {
-      sendMiniKitEvent({
-        command: "share" /* Share */,
-        version: _MiniKit.miniKitCommandVersion["share" /* Share */],
-        payload
-      });
-      navigator.share(payload);
-    } else {
-      formatShareInput(payload).then((formattedResult) => {
-        sendMiniKitEvent({
-          command: "share" /* Share */,
-          version: _MiniKit.miniKitCommandVersion["share" /* Share */],
-          payload: formattedResult
-        });
-      }).catch((error) => {
-        console.error("Failed to format share input", error);
-      });
-      _MiniKit.subscribe("miniapp-share" /* MiniAppShare */, (payload2) => {
-        console.log("Share Response", payload2);
-      });
+    return isInstalled;
+  }
+  // ============================================================================
+  // Commands
+  // ============================================================================
+  static getContext() {
+    return {
+      events: this.eventManager,
+      state: this.stateManager
+    };
+  }
+  static get commands() {
+    if (!this.commandsInstance) {
+      this.commandsInstance = createCommands(this.getContext());
     }
-    return payload;
-  },
-  chat: (payload) => {
-    if (typeof window === "undefined" || !_MiniKit.isCommandAvailable["chat" /* Chat */]) {
-      console.error(
-        "'chat' command is unavailable. Check MiniKit.install() or update the app version"
+    return this.commandsInstance;
+  }
+  static get commandsAsync() {
+    if (!this.asyncCommandsInstance) {
+      this.asyncCommandsInstance = createAsyncCommands(
+        this.getContext(),
+        this.commands
       );
-      return null;
     }
-    if (payload.message.length === 0) {
-      console.error("'chat' command requires a non-empty message");
-      return null;
-    }
-    sendMiniKitEvent({
-      command: "chat" /* Chat */,
-      version: _MiniKit.miniKitCommandVersion["chat" /* Chat */],
-      payload
-    });
-    return payload;
+    return this.asyncCommandsInstance;
   }
 };
-/**
- * This object contains async versions of all the commands.
- * Instead of using event listeners, you can just `await` these.
- *
- * They return a standardized object
- *
- * commandPayload - object returned by the command function
- *
- * finalPayload - object returned by the event listener, or in other words, WorldApp response
- */
-_MiniKit.commandsAsync = {
-  verify: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-verify-action" /* MiniAppVerifyAction */,
-          "verify" /* Verify */,
-          () => _MiniKit.commands.verify(payload)
-        );
-        if (response.finalPayload.status === "success" && response.finalPayload.verification_level === import_idkit_core3.VerificationLevel.Orb) {
-          response.finalPayload.proof = await compressAndPadProof(
-            response.finalPayload.proof
-          );
-        }
-        resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  pay: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-payment" /* MiniAppPayment */,
-          "pay" /* Pay */,
-          () => _MiniKit.commands.pay(payload)
-        );
-        resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  walletAuth: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-wallet-auth" /* MiniAppWalletAuth */,
-          "wallet-auth" /* WalletAuth */,
-          () => _MiniKit.commands.walletAuth(payload)
-        );
-        return resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  sendTransaction: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-send-transaction" /* MiniAppSendTransaction */,
-          "send-transaction" /* SendTransaction */,
-          () => _MiniKit.commands.sendTransaction(payload)
-        );
-        return resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  signMessage: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-sign-message" /* MiniAppSignMessage */,
-          "sign-message" /* SignMessage */,
-          () => _MiniKit.commands.signMessage(payload)
-        );
-        return resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  signTypedData: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-sign-typed-data" /* MiniAppSignTypedData */,
-          "sign-typed-data" /* SignTypedData */,
-          () => _MiniKit.commands.signTypedData(payload)
-        );
-        return resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  shareContacts: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-share-contacts" /* MiniAppShareContacts */,
-          "share-contacts" /* ShareContacts */,
-          () => _MiniKit.commands.shareContacts(payload)
-        );
-        return resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  requestPermission: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-request-permission" /* MiniAppRequestPermission */,
-          "request-permission" /* RequestPermission */,
-          () => _MiniKit.commands.requestPermission(payload)
-        );
-        resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  getPermissions: async () => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-get-permissions" /* MiniAppGetPermissions */,
-          "get-permissions" /* GetPermissions */,
-          () => _MiniKit.commands.getPermissions()
-        );
-        resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  sendHapticFeedback: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-send-haptic-feedback" /* MiniAppSendHapticFeedback */,
-          "send-haptic-feedback" /* SendHapticFeedback */,
-          () => _MiniKit.commands.sendHapticFeedback(payload)
-        );
-        resolve(response);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  share: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-share" /* MiniAppShare */,
-          "share" /* Share */,
-          () => _MiniKit.commands.share(payload)
-        );
-        resolve({
-          commandPayload: response.commandPayload,
-          finalPayload: response.finalPayload
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-  },
-  chat: async (payload) => {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const response = await _MiniKit.awaitCommand(
-          "miniapp-chat" /* MiniAppChat */,
-          "chat" /* Chat */,
-          () => _MiniKit.commands.chat(payload)
-        );
-        resolve({
-          commandPayload: response.commandPayload,
-          finalPayload: response.finalPayload
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
+_MiniKit.eventManager = new EventManager();
+_MiniKit.stateManager = new MiniKitState();
+_MiniKit.commandsInstance = null;
+_MiniKit.asyncCommandsInstance = null;
+// ============================================================================
+// Utility Methods
+// ============================================================================
+_MiniKit.getUserByAddress = async (address) => {
+  return _MiniKit.stateManager.getUserByAddress(address);
+};
+_MiniKit.getUserByUsername = async (username) => {
+  return _MiniKit.stateManager.getUserByUsername(username);
+};
+_MiniKit.getUserInfo = _MiniKit.getUserByAddress;
+_MiniKit.getMiniAppUrl = (appId, path) => {
+  const baseUrl = new URL("https://world.org/mini-app");
+  baseUrl.searchParams.append("app_id", appId);
+  if (path) {
+    const fullPath = path.startsWith("/") ? path : `/${path}`;
+    baseUrl.searchParams.append("path", encodeURIComponent(fullPath));
+  }
+  return baseUrl.toString();
+};
+_MiniKit.showProfileCard = (username, walletAddress) => {
+  if (!username && !walletAddress) {
+    console.error(
+      "Either username or walletAddress must be provided to show profile card"
+    );
+    return;
+  }
+  if (username) {
+    window.open(
+      `worldapp://profile?username=${encodeURIComponent(username)}`
+    );
+  } else {
+    window.open(
+      `worldapp://profile?address=${encodeURIComponent(walletAddress || "")}`
+    );
   }
 };
 var MiniKit = _MiniKit;
 
 // index.ts
-var import_idkit_core4 = require("@worldcoin/idkit-core");
+var import_idkit_core6 = require("@worldcoin/idkit-core");
 var import_backend = require("@worldcoin/idkit-core/backend");
 
 // helpers/address-book/index.ts
@@ -1747,13 +2021,12 @@ var getIsUserVerified = async (walletAddress, rpcUrl) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  COMMAND_VERSIONS,
   ChatErrorCodes,
   ChatErrorMessage,
   Command,
   GetPermissionsErrorCodes,
   GetPermissionsErrorMessage,
-  MicrophoneErrorCodes,
-  MicrophoneErrorMessage,
   MiniAppLaunchLocation,
   MiniKit,
   MiniKitInstallErrorCodes,
@@ -1761,7 +2034,6 @@ var getIsUserVerified = async (walletAddress, rpcUrl) => {
   Network,
   PaymentErrorCodes,
   PaymentErrorMessage,
-  PaymentValidationErrors,
   Permission,
   RequestPermissionErrorCodes,
   RequestPermissionErrorMessage,
@@ -1781,14 +2053,43 @@ var getIsUserVerified = async (walletAddress, rpcUrl) => {
   TokenDecimals,
   Tokens,
   VerificationErrorCodes,
-  VerificationErrorMessage,
   VerificationLevel,
   WalletAuthErrorCodes,
   WalletAuthErrorMessage,
+  createAsyncCommands,
+  createChatAsyncCommand,
+  createChatCommand,
+  createCommands,
+  createGetPermissionsAsyncCommand,
+  createGetPermissionsCommand,
+  createPayAsyncCommand,
+  createPayCommand,
+  createRequestPermissionAsyncCommand,
+  createRequestPermissionCommand,
+  createSendHapticFeedbackAsyncCommand,
+  createSendHapticFeedbackCommand,
+  createSendTransactionAsyncCommand,
+  createSendTransactionCommand,
+  createShareAsyncCommand,
+  createShareCommand,
+  createShareContactsAsyncCommand,
+  createShareContactsCommand,
+  createSignMessageAsyncCommand,
+  createSignMessageCommand,
+  createSignTypedDataAsyncCommand,
+  createSignTypedDataCommand,
+  createVerifyAsyncCommand,
+  createVerifyCommand,
+  createWalletAuthAsyncCommand,
+  createWalletAuthCommand,
   getIsUserVerified,
+  isCommandAvailable,
   mapWorldAppLaunchLocation,
   parseSiweMessage,
+  sendMiniKitEvent,
+  setCommandAvailable,
   tokenToDecimals,
+  validateCommands,
   verifyCloudProof,
   verifySiweMessage
 });