@worldcoin/minikit-js/build/index.cjs

minikit-js is our SDK for building mini-apps.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// index.ts
var core_exports = {};
__export(core_exports, {
  AttestationErrorCodes: () => AttestationErrorCodes,
  AttestationErrorMessage: () => AttestationErrorMessage,
  COMMAND_VERSIONS: () => COMMAND_VERSIONS,
  ChatErrorCodes: () => ChatErrorCodes,
  ChatErrorMessage: () => ChatErrorMessage,
  Command: () => Command,
  GetPermissionsErrorCodes: () => GetPermissionsErrorCodes,
  GetPermissionsErrorMessage: () => GetPermissionsErrorMessage,
  MiniAppLaunchLocation: () => MiniAppLaunchLocation,
  MiniKit: () => MiniKit,
  MiniKitInstallErrorCodes: () => MiniKitInstallErrorCodes,
  MiniKitInstallErrorMessage: () => MiniKitInstallErrorMessage,
  Network: () => Network,
  PaymentErrorCodes: () => PaymentErrorCodes,
  PaymentErrorMessage: () => PaymentErrorMessage,
  Permission: () => Permission,
  RequestPermissionErrorCodes: () => RequestPermissionErrorCodes,
  RequestPermissionErrorMessage: () => RequestPermissionErrorMessage,
  ResponseEvent: () => ResponseEvent,
  SendHapticFeedbackErrorCodes: () => SendHapticFeedbackErrorCodes,
  SendHapticFeedbackErrorMessage: () => SendHapticFeedbackErrorMessage,
  SendTransactionErrorCodes: () => SendTransactionErrorCodes,
  SendTransactionErrorMessage: () => SendTransactionErrorMessage,
  ShareContactsErrorCodes: () => ShareContactsErrorCodes,
  ShareContactsErrorMessage: () => ShareContactsErrorMessage,
  ShareFilesErrorCodes: () => ShareFilesErrorCodes,
  ShareFilesErrorMessage: () => ShareFilesErrorMessage,
  SignMessageErrorCodes: () => SignMessageErrorCodes,
  SignMessageErrorMessage: () => SignMessageErrorMessage,
  SignTypedDataErrorCodes: () => SignTypedDataErrorCodes,
  SignTypedDataErrorMessage: () => SignTypedDataErrorMessage,
  TokenDecimals: () => TokenDecimals,
  Tokens: () => Tokens,
  VerificationErrorCodes: () => import_idkit_core2.AppErrorCodes,
  VerificationLevel: () => import_idkit_core6.VerificationLevel,
  WalletAuthErrorCodes: () => WalletAuthErrorCodes,
  WalletAuthErrorMessage: () => WalletAuthErrorMessage,
  createAsyncCommands: () => createAsyncCommands,
  createAttestationAsyncCommand: () => createAttestationAsyncCommand,
  createAttestationCommand: () => createAttestationCommand,
  createChatAsyncCommand: () => createChatAsyncCommand,
  createChatCommand: () => createChatCommand,
  createCloseMiniAppCommand: () => createCloseMiniAppCommand,
  createCommands: () => createCommands,
  createGetPermissionsAsyncCommand: () => createGetPermissionsAsyncCommand,
  createGetPermissionsCommand: () => createGetPermissionsCommand,
  createPayAsyncCommand: () => createPayAsyncCommand,
  createPayCommand: () => createPayCommand,
  createRequestPermissionAsyncCommand: () => createRequestPermissionAsyncCommand,
  createRequestPermissionCommand: () => createRequestPermissionCommand,
  createSendHapticFeedbackAsyncCommand: () => createSendHapticFeedbackAsyncCommand,
  createSendHapticFeedbackCommand: () => createSendHapticFeedbackCommand,
  createSendTransactionAsyncCommand: () => createSendTransactionAsyncCommand,
  createSendTransactionCommand: () => createSendTransactionCommand,
  createShareAsyncCommand: () => createShareAsyncCommand,
  createShareCommand: () => createShareCommand,
  createShareContactsAsyncCommand: () => createShareContactsAsyncCommand,
  createShareContactsCommand: () => createShareContactsCommand,
  createSignMessageAsyncCommand: () => createSignMessageAsyncCommand,
  createSignMessageCommand: () => createSignMessageCommand,
  createSignTypedDataAsyncCommand: () => createSignTypedDataAsyncCommand,
  createSignTypedDataCommand: () => createSignTypedDataCommand,
  createVerifyAsyncCommand: () => createVerifyAsyncCommand,
  createVerifyCommand: () => createVerifyCommand,
  createWalletAuthAsyncCommand: () => createWalletAuthAsyncCommand,
  createWalletAuthCommand: () => createWalletAuthCommand,
  getIsUserVerified: () => getIsUserVerified,
  isCommandAvailable: () => isCommandAvailable,
  mapWorldAppLaunchLocation: () => mapWorldAppLaunchLocation,
  parseSiweMessage: () => parseSiweMessage,
  sendMiniKitEvent: () => sendMiniKitEvent,
  setCommandAvailable: () => setCommandAvailable,
  tokenToDecimals: () => tokenToDecimals,
  validateCommands: () => validateCommands,
  verifyCloudProof: () => import_backend.verifyCloudProof,
  verifySiweMessage: () => verifySiweMessage
});
module.exports = __toCommonJS(core_exports);

// helpers/send-webview-event.ts
var sendWebviewEvent = (payload) => {
  if (window.webkit) {
    window.webkit?.messageHandlers?.minikit?.postMessage?.(payload);
  } else if (window.Android) {
    window.Android.postMessage?.(JSON.stringify(payload));
  }
};

// commands/types.ts
var Command = /* @__PURE__ */ ((Command2) => {
  Command2["Verify"] = "verify";
  Command2["Pay"] = "pay";
  Command2["WalletAuth"] = "wallet-auth";
  Command2["SendTransaction"] = "send-transaction";
  Command2["SignMessage"] = "sign-message";
  Command2["SignTypedData"] = "sign-typed-data";
  Command2["ShareContacts"] = "share-contacts";
  Command2["RequestPermission"] = "request-permission";
  Command2["GetPermissions"] = "get-permissions";
  Command2["SendHapticFeedback"] = "send-haptic-feedback";
  Command2["Share"] = "share";
  Command2["Chat"] = "chat";
  Command2["Attestation"] = "attestation";
  Command2["CloseMiniApp"] = "close-miniapp";
  return Command2;
})(Command || {});
var ResponseEvent = /* @__PURE__ */ ((ResponseEvent3) => {
  ResponseEvent3["MiniAppVerifyAction"] = "miniapp-verify-action";
  ResponseEvent3["MiniAppPayment"] = "miniapp-payment";
  ResponseEvent3["MiniAppWalletAuth"] = "miniapp-wallet-auth";
  ResponseEvent3["MiniAppSendTransaction"] = "miniapp-send-transaction";
  ResponseEvent3["MiniAppSignMessage"] = "miniapp-sign-message";
  ResponseEvent3["MiniAppSignTypedData"] = "miniapp-sign-typed-data";
  ResponseEvent3["MiniAppShareContacts"] = "miniapp-share-contacts";
  ResponseEvent3["MiniAppRequestPermission"] = "miniapp-request-permission";
  ResponseEvent3["MiniAppGetPermissions"] = "miniapp-get-permissions";
  ResponseEvent3["MiniAppSendHapticFeedback"] = "miniapp-send-haptic-feedback";
  ResponseEvent3["MiniAppShare"] = "miniapp-share";
  ResponseEvent3["MiniAppMicrophone"] = "miniapp-microphone";
  ResponseEvent3["MiniAppChat"] = "miniapp-chat";
  ResponseEvent3["MiniAppAttestation"] = "miniapp-attestation";
  return ResponseEvent3;
})(ResponseEvent || {});
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,
  ["attestation" /* Attestation */]: 1,
  ["close-miniapp" /* CloseMiniApp */]: 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,
  ["attestation" /* Attestation */]: false,
  ["close-miniapp" /* CloseMiniApp */]: 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/attestation.ts
var AttestationErrorCodes = /* @__PURE__ */ ((AttestationErrorCodes2) => {
  AttestationErrorCodes2["Unauthorized"] = "unauthorized";
  AttestationErrorCodes2["AttestationFailed"] = "attestation_failed";
  AttestationErrorCodes2["IntegrityFailed"] = "integrity_failed";
  AttestationErrorCodes2["InvalidInput"] = "invalid_input";
  AttestationErrorCodes2["UnsupportedVersion"] = "unsupported_version";
  return AttestationErrorCodes2;
})(AttestationErrorCodes || {});
var AttestationErrorMessage = {
  ["unauthorized" /* Unauthorized */]: "App is not whitelisted for attestation.",
  ["attestation_failed" /* AttestationFailed */]: "Failed to obtain token from attestation gateway.",
  ["integrity_failed" /* IntegrityFailed */]: "Platform integrity check failed.",
  ["invalid_input" /* InvalidInput */]: "Invalid request payload.",
  ["unsupported_version" /* UnsupportedVersion */]: "Command version is not supported."
};
function createAttestationCommand(_ctx) {
  return (input) => {
    if (typeof window === "undefined" || !isCommandAvailable("attestation" /* Attestation */)) {
      console.error(
        "'attestation' command is unavailable. Check MiniKit.install() or update the app version"
      );
      return null;
    }
    if (!input.requestHash || input.requestHash.length === 0) {
      console.error("'attestation' command requires a non-empty requestHash");
      return null;
    }
    const payload = {
      request_hash: input.requestHash
    };
    sendMiniKitEvent({
      command: "attestation" /* Attestation */,
      version: COMMAND_VERSIONS["attestation" /* Attestation */],
      payload
    });
    return payload;
  };
}
function createAttestationAsyncCommand(ctx, syncCommand) {
  return async (input) => {
    return new Promise((resolve, reject) => {
      try {
        const handleResponse = (response) => {
          ctx.events.unsubscribe("miniapp-attestation" /* MiniAppAttestation */);
          resolve({ commandPayload, finalPayload: response });
        };
        ctx.events.subscribe(
          "miniapp-attestation" /* MiniAppAttestation */,
          handleResponse
        );
        const commandPayload = syncCommand(input);
        if (!commandPayload) {
          ctx.events.unsubscribe("miniapp-attestation" /* MiniAppAttestation */);
          reject(
            new Error(
              "'attestation' command failed: command unavailable or invalid input"
            )
          );
        }
      } catch (error) {
        ctx.events.unsubscribe("miniapp-attestation" /* MiniAppAttestation */);
        reject(error);
      }
    });
  };
}

// 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/close-miniapp.ts
function createCloseMiniAppCommand(_ctx) {
  return () => {
    if (typeof window === "undefined" || !isCommandAvailable("close-miniapp" /* CloseMiniApp */)) {
      console.error(
        "'closeMiniApp' command is unavailable. Check MiniKit.install() or update the app version"
      );
      return false;
    }
    sendMiniKitEvent({
      command: "close-miniapp" /* CloseMiniApp */,
      version: COMMAND_VERSIONS["close-miniapp" /* CloseMiniApp */],
      payload: {}
    });
    return true;
  };
}

// 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";
  PaymentErrorCodes2["PaymentRejected"] = "payment_rejected";
  PaymentErrorCodes2["InvalidReceiver"] = "invalid_receiver";
  PaymentErrorCodes2["InsufficientBalance"] = "insufficient_balance";
  PaymentErrorCodes2["TransactionFailed"] = "transaction_failed";
  PaymentErrorCodes2["GenericError"] = "generic_error";
  PaymentErrorCodes2["UserBlocked"] = "user_blocked";
  return PaymentErrorCodes2;
})(PaymentErrorCodes || {});
var PaymentErrorMessage = {
  ["input_error" /* InputError */]: "There was a problem with this request. Please try again or contact the app owner.",
  ["user_rejected" /* UserRejected */]: "You have cancelled the payment in World App.",
  ["payment_rejected" /* PaymentRejected */]: "You've cancelled the payment in World App.",
  ["invalid_receiver" /* InvalidReceiver */]: "The receiver address is invalid. Please contact the app owner.",
  ["insufficient_balance" /* InsufficientBalance */]: "You do not have enough balance to complete this transaction.",
  ["transaction_failed" /* TransactionFailed */]: "The transaction failed. Please try again.",
  ["generic_error" /* GenericError */]: "Something unexpected went wrong. Please try again.",
  ["user_blocked" /* UserBlocked */]: "User's region is blocked from making payments."
};
function createPayCommand(_ctx) {
  return (payload) => {
    if (typeof window === "undefined" || !isCommandAvailable("pay" /* Pay */)) {
      console.error(
        "'pay' command is unavailable. Check MiniKit.install() or update the app version"
      );
      return null;
    }
    if (!validatePaymentPayload(payload)) {
      return null;
    }
    const eventPayload = {
      ...payload,
      network: "worldchain" /* WorldChain */
    };
    sendMiniKitEvent({
      command: "pay" /* Pay */,
      version: COMMAND_VERSIONS["pay" /* Pay */],
      payload: eventPayload
    });
    return eventPayload;
  };
}
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";
  return SendHapticFeedbackErrorCodes2;
})(SendHapticFeedbackErrorCodes || {});
var SendHapticFeedbackErrorMessage = {
  ["generic_error" /* GenericError */]: "Something unexpected went wrong.",
  ["user_rejected" /* UserRejected */]: "User rejected the request."
};
function createSendHapticFeedbackCommand(_ctx) {
  return (payload) => {
    if (typeof window === "undefined" || !isCommandAvailable("send-haptic-feedback" /* SendHapticFeedback */)) {
      console.error(
        "'sendHapticFeedback' command is unavailable. Check MiniKit.install() or update the app version"
      );
      return null;
    }
    sendMiniKitEvent({
      command: "send-haptic-feedback" /* SendHapticFeedback */,
      version: COMMAND_VERSIONS["send-haptic-feedback" /* SendHapticFeedback */],
      payload
    });
    return payload;
  };
}
function createSendHapticFeedbackAsyncCommand(ctx, syncCommand) {
  return async (payload) => {
    return new Promise((resolve, reject) => {
      try {
        let commandPayload = null;
        const handleResponse = (response) => {
          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);
      }
    });
  };
}

// 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));
  }
  const values = Object.values(input);
  return values.map((value) => objectValuesToArrayRecursive(value));
};
var processPayload = (payload) => {
  if (typeof payload === "boolean" || typeof payload === "string" || payload === null || payload === void 0) {
    return payload;
  }
  if (typeof payload === "number" || typeof payload === "bigint") {
    return String(payload);
  }
  if (Array.isArray(payload)) {
    return payload.map((value) => processPayload(value));
  }
  if (typeof payload === "object") {
    const result = { ...payload };
    if ("value" in result && result.value !== void 0) {
      if (typeof result.value !== "string") {
        result.value = String(result.value);
      }
      if (!isValidHex(result.value)) {
        console.error(
          "Transaction value must be a valid hex string",
          result.value
        );
        throw new Error(
          `Transaction value must be a valid hex string: ${result.value}`
        );
      }
    }
    for (const key in result) {
      if (Object.prototype.hasOwnProperty.call(result, key)) {
        result[key] = processPayload(result[key]);
      }
    }
    return result;
  }
  return payload;
};
var validateSendTransactionPayload = (payload) => {
  if (payload.formatPayload) {
    const formattedPayload = processPayload(payload);
    formattedPayload.transaction = formattedPayload.transaction.map((tx) => {
      const args = objectValuesToArrayRecursive(tx.args);
      return {
        ...tx,
        args
      };
    });
    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;
var MAX_TOTAL_SIZE_MB = 50;
var MAX_TOTAL_SIZE_BYTES = MAX_TOTAL_SIZE_MB * 1024 * 1024;
var processFile = async (file) => {
  const buffer = await file.arrayBuffer();
  const uint8Array = new Uint8Array(buffer);
  let binaryString = "";
  const K_CHUNK_SIZE = 32768;
  for (let i = 0; i < uint8Array.length; i += K_CHUNK_SIZE) {
    const chunk = uint8Array.subarray(
      i,
      Math.min(i + K_CHUNK_SIZE, uint8Array.length)
    );
    binaryString += String.fromCharCode.apply(
      null,
      Array.from(chunk)
      // Convert Uint8Array chunk to number[]
    );
  }
  const base64Data = btoa(binaryString);
  return {
    name: file.name,
    type: file.type,
    data: base64Data
  };
};
var formatShareInput = async (input) => {
  if (!input.files) {
    return {
      title: input.title,
      text: input.text,
      url: input.url
    };
  }
  if (!Array.isArray(input.files)) {
    throw new Error('The "files" property must be an array.');
  }
  if (input.files.length === 0) {
  } else {
    if (input.files.length > MAX_FILES) {
      throw new Error(`Cannot share more than ${MAX_FILES} files.`);
    }
    let totalSize = 0;
    for (const file of input.files) {
      if (!(file instanceof File)) {
        throw new Error(
          `Each item in the 'files' array must be a File object. Received: ${typeof file}`
        );
      }
      totalSize += file.size;
    }
    if (totalSize > MAX_TOTAL_SIZE_BYTES) {
      throw new Error(`Total file size cannot exceed ${MAX_TOTAL_SIZE_MB}MB.`);
    }
  }
  const fileProcessingPromises = input.files.map((file) => processFile(file));
  const processedFiles = await Promise.all(fileProcessingPromises);
  return {
    files: processedFiles,
    title: input.title,
    text: input.text,
    url: input.url
  };
};

// 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"
};
function createShareCommand(ctx) {
  return (payload) => {
    if (typeof window === "undefined" || !isCommandAvailable("share" /* Share */)) {
      console.error(
        "'share' command is unavailable. Check MiniKit.install() or update the app version"
      );
      return null;
    }
    if (ctx.state.deviceProperties.deviceOS === "ios" && typeof navigator !== "undefined") {
      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) => {
    console.warn(
      "signTypedData is deprecated. Use signMessage or sendTransaction instead."
    );
    if (typeof window === "undefined" || !isCommandAvailable("sign-typed-data" /* SignTypedData */)) {
      console.error(
        "'signTypedData' command is unavailable. Check MiniKit.install() or update the app version"
      );
      return null;
    }
    if (!payload.chainId) {
      payload.chainId = 480;
    }
    sendMiniKitEvent({
      command: "sign-typed-data" /* SignTypedData */,
      version: COMMAND_VERSIONS["sign-typed-data" /* SignTypedData */],
      payload
    });
    return payload;
  };
}
function createSignTypedDataAsyncCommand(ctx, syncCommand) {
  return async (payload) => {
    return new Promise((resolve, reject) => {
      try {
        let commandPayload = null;
        const handleResponse = (response) => {
          ctx.events.unsubscribe("miniapp-sign-typed-data" /* MiniAppSignTypedData */);
          resolve({ commandPayload, finalPayload: response });
        };
        ctx.events.subscribe(
          "miniapp-sign-typed-data" /* MiniAppSignTypedData */,
          handleResponse
        );
        commandPayload = syncCommand(payload);
      } catch (error) {
        reject(error);
      }
    });
  };
}

// commands/verify.ts
var import_idkit_core = require("@worldcoin/idkit-core");
var import_hashing = require("@worldcoin/idkit-core/hashing");
var import_idkit_core2 = require("@worldcoin/idkit-core");
function createVerifyCommand(ctx) {
  return (payload) => {
    if (typeof window === "undefined" || !isCommandAvailable("verify" /* Verify */)) {
      console.error(
        "'verify' command is unavailable. Check MiniKit.install() or update the app version"
      );
      return null;
    }
    if (Array.isArray(payload.verification_level) && payload.verification_level.length === 0) {
      console.error("'verification_level' must not be an empty array");
      return null;
    }
    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
    const eventPayload = {
      action: (0, import_hashing.encodeAction)(payload.action),
      signal: (0, import_hashing.generateSignal)(payload.signal).digest,
      verification_level: payload.verification_level || import_idkit_core.VerificationLevel.Orb,
      timestamp
    };
    ctx.events.setVerifyActionProcessingOptions({
      skip_proof_compression: payload.skip_proof_compression
    });
    sendMiniKitEvent({
      command: "verify" /* Verify */,
      version: COMMAND_VERSIONS["verify" /* Verify */],
      payload: eventPayload
    });
    return eventPayload;
  };
}
function createVerifyAsyncCommand(ctx, syncCommand) {
  let hasInFlightVerifyRequest = false;
  return async (payload) => {
    if (hasInFlightVerifyRequest) {
      return Promise.reject(
        new Error(
          "A verify request is already in flight. Wait for the current request to complete before sending another."
        )
      );
    }
    return new Promise((resolve, reject) => {
      try {
        hasInFlightVerifyRequest = true;
        let commandPayload = null;
        const handleResponse = (response) => {
          ctx.events.unsubscribe("miniapp-verify-action" /* MiniAppVerifyAction */);
          hasInFlightVerifyRequest = false;
          resolve({ commandPayload, finalPayload: response });
        };
        ctx.events.subscribe(
          "miniapp-verify-action" /* MiniAppVerifyAction */,
          handleResponse
        );
        commandPayload = syncCommand(payload);
        if (commandPayload === null) {
          ctx.events.unsubscribe("miniapp-verify-action" /* MiniAppVerifyAction */);
          hasInFlightVerifyRequest = false;
          reject(
            new Error(
              "Failed to send verify command. Ensure MiniKit is installed and the verify command is available."
            )
          );
        }
      } catch (error) {
        hasInFlightVerifyRequest = false;
        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 = "";
  if (siweMessageData.scheme) {
    siweMessage += `${siweMessageData.scheme}://${siweMessageData.domain} wants you to sign in with your Ethereum account:
`;
  } else {
    siweMessage += `${siweMessageData.domain} wants you to sign in with your Ethereum account:
`;
  }
  if (siweMessageData.address) {
    siweMessage += `${siweMessageData.address}
`;
  } else {
    siweMessage += "{address}\n";
  }
  siweMessage += "\n";
  if (siweMessageData.statement) {
    siweMessage += `${siweMessageData.statement}
`;
  }
  siweMessage += "\n";
  siweMessage += `URI: ${siweMessageData.uri}
`;
  siweMessage += `Version: ${siweMessageData.version}
`;
  siweMessage += `Chain ID: ${siweMessageData.chain_id}
`;
  siweMessage += `Nonce: ${siweMessageData.nonce}
`;
  siweMessage += `Issued At: ${siweMessageData.issued_at}
`;
  if (siweMessageData.expiration_time) {
    siweMessage += `Expiration Time: ${siweMessageData.expiration_time}
`;
  }
  if (siweMessageData.not_before) {
    siweMessage += `Not Before: ${siweMessageData.not_before}
`;
  }
  if (siweMessageData.request_id) {
    siweMessage += `Request ID: ${siweMessageData.request_id}
`;
  }
  return siweMessage;
};
var verifySiweMessage = (payload, nonce, statement, requestId, userProvider) => {
  if (payload.version === 1) {
    return verifySiweMessageV1(
      payload,
      nonce,
      statement,
      requestId,
      userProvider
    );
  } else {
    return verifySiweMessageV2(
      payload,
      nonce,
      statement,
      requestId,
      userProvider
    );
  }
};
var validateMessage = (siweMessageData, nonce, statement, requestId) => {
  if (siweMessageData.expiration_time) {
    const expirationTime = new Date(siweMessageData.expiration_time);
    if (expirationTime < /* @__PURE__ */ new Date()) {
      throw new Error("Expired message");
    }
  }
  if (siweMessageData.not_before) {
    const notBefore = new Date(siweMessageData.not_before);
    if (notBefore > /* @__PURE__ */ new Date()) {
      throw new Error("Not Before time has not passed");
    }
  }
  if (nonce && siweMessageData.nonce !== nonce) {
    throw new Error(
      `Nonce mismatch. Got: ${siweMessageData.nonce}, Expected: ${nonce}`
    );
  }
  if (statement && siweMessageData.statement !== statement) {
    throw new Error(
      `Statement mismatch. Got: ${siweMessageData.statement}, Expected: ${statement}`
    );
  }
  if (requestId && siweMessageData.request_id !== requestId) {
    throw new Error(
      `Request ID mismatch. Got: ${siweMessageData.request_id}, Expected: ${requestId}`
    );
  }
  return true;
};
var verifySiweMessageV1 = async (payload, nonce, statement, requestId, userProvider) => {
  if (typeof window !== "undefined") {
    throw new Error("Wallet auth payload can only be verified in the backend");
  }
  const { message, signature, address } = payload;
  const siweMessageData = parseSiweMessage(message);
  validateMessage(siweMessageData, nonce, statement, requestId);
  let provider = userProvider || (0, import_viem.createPublicClient)({ chain: import_chains.worldchain, transport: (0, import_viem.http)() });
  const signedMessage = `${ERC_191_PREFIX}${message.length}${message}`;
  const hashedMessage = (0, import_viem.hashMessage)(signedMessage);
  const contract = (0, import_viem.getContract)({
    address,
    abi: SAFE_CONTRACT_ABI,
    client: provider
  });
  try {
    const recoveredAddress = await (0, import_viem.recoverAddress)({
      hash: hashedMessage,
      signature: `0x${signature}`
    });
    const isOwner = await contract.read.isOwner([recoveredAddress]);
    if (!isOwner) {
      throw new Error("Signature verification failed, invalid owner");
    }
  } catch (error) {
    th