@worldcoin/minikit-js 2.0.2 → 2.0.3

package/build/chunk-DZ2YRSIU.js

@@ -0,0 +1,216 @@
+// src/commands/types.ts
+var Command = /* @__PURE__ */ ((Command2) => {
+  Command2["Attestation"] = "attestation";
+  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["CloseMiniApp"] = "close-miniapp";
+  return Command2;
+})(Command || {});
+var ResponseEvent = /* @__PURE__ */ ((ResponseEvent2) => {
+  ResponseEvent2["MiniAppAttestation"] = "miniapp-attestation";
+  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 || {});
+var COMMAND_VERSIONS = {
+  ["attestation" /* Attestation */]: 1,
+  ["pay" /* Pay */]: 1,
+  ["wallet-auth" /* WalletAuth */]: 2,
+  ["send-transaction" /* SendTransaction */]: 2,
+  ["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,
+  ["close-miniapp" /* CloseMiniApp */]: 1
+};
+var commandAvailability = {
+  ["attestation" /* Attestation */]: 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,
+  ["close-miniapp" /* CloseMiniApp */]: false
+};
+function isCommandAvailable(command) {
+  return commandAvailability[command] ?? false;
+}
+function setCommandAvailable(command, available) {
+  commandAvailability[command] = available;
+}
+function validateCommands(worldAppSupportedCommands) {
+  let allCommandsValid = true;
+  Object.entries(COMMAND_VERSIONS).forEach(([commandName, version]) => {
+    const commandInput = worldAppSupportedCommands.find(
+      (cmd) => cmd.name === commandName
+    );
+    let isCommandValid = false;
+    if (!commandInput) {
+      console.warn(
+        `Command ${commandName} is not supported by the app. Try updating the app version`
+      );
+    } else {
+      if (commandInput.supported_versions.includes(version)) {
+        setCommandAvailable(commandName, true);
+        isCommandValid = true;
+      } else {
+        isCommandValid = true;
+        console.warn(
+          `Command ${commandName} version ${version} is not supported by the app. Supported versions: ${commandInput.supported_versions.join(", ")}. This is not an error, but it is recommended to update the World App version.`
+        );
+        setCommandAvailable(commandName, true);
+      }
+    }
+    if (!isCommandValid) {
+      allCommandsValid = false;
+    }
+  });
+  return allCommandsValid;
+}
+function sendMiniKitEvent(payload) {
+  if (window.webkit) {
+    window.webkit?.messageHandlers?.minikit?.postMessage?.(payload);
+  } else if (window.Android) {
+    window.Android?.postMessage?.(JSON.stringify(payload));
+  }
+}
+function isInWorldApp() {
+  return typeof window !== "undefined" && Boolean(window.WorldApp);
+}
+var FallbackRequiredError = class extends Error {
+  constructor(command) {
+    super(
+      `${command} requires a fallback function when running outside World App. Provide a fallback option: MiniKit.${command}({ ..., fallback: () => yourFallback() })`
+    );
+    this.name = "FallbackRequiredError";
+  }
+};
+var CommandUnavailableError = class extends Error {
+  constructor(command, reason) {
+    const messages = {
+      notInWorldApp: "Not running inside World App",
+      commandNotSupported: "Command not supported in this environment",
+      oldAppVersion: "World App version does not support this command"
+    };
+    super(`${command} is unavailable: ${messages[reason]}`);
+    this.name = "CommandUnavailableError";
+    this.reason = reason;
+  }
+};
+
+// src/commands/fallback.ts
+var PartialExecutionError = class extends Error {
+  constructor(message, submitted, cause) {
+    super(message);
+    this.name = "PartialExecutionError";
+    this.submitted = submitted;
+    this.cause = cause;
+  }
+};
+async function executeWithFallback(options) {
+  const {
+    command,
+    nativeExecutor,
+    wagmiFallback,
+    customFallback,
+    requiresFallback = false
+  } = options;
+  const inWorldApp = isInWorldApp();
+  const commandAvailable = isCommandAvailable(command);
+  let nativeError;
+  if (inWorldApp && commandAvailable) {
+    try {
+      const data = await nativeExecutor();
+      return { data, executedWith: "minikit" };
+    } catch (error) {
+      nativeError = error;
+      console.warn(`Native ${command} failed, attempting fallback:`, error);
+    }
+  }
+  if (!inWorldApp && wagmiFallback) {
+    try {
+      const data = await wagmiFallback();
+      return { data, executedWith: "wagmi" };
+    } catch (error) {
+      if (error instanceof PartialExecutionError || error instanceof Error && error.name === "PartialExecutionError") {
+        throw error;
+      }
+      console.warn(`Wagmi fallback for ${command} failed:`, error);
+    }
+  }
+  if (!inWorldApp && customFallback) {
+    const data = await customFallback();
+    return { data, executedWith: "fallback" };
+  }
+  if (nativeError) {
+    throw nativeError;
+  }
+  if (requiresFallback && !inWorldApp) {
+    throw new FallbackRequiredError(command);
+  }
+  throw new CommandUnavailableError(command, determineFallbackReason(command));
+}
+function determineFallbackReason(command) {
+  if (!isInWorldApp()) {
+    return "notInWorldApp";
+  }
+  if (!isCommandAvailable(command)) {
+    return "oldAppVersion";
+  }
+  return "commandNotSupported";
+}
+
+// src/commands/fallback-adapter-registry.ts
+var FALLBACK_ADAPTER_KEY = "__minikit_fallback_adapter__";
+function setFallbackAdapter(adapter) {
+  globalThis[FALLBACK_ADAPTER_KEY] = adapter;
+}
+function getFallbackAdapter() {
+  return globalThis[FALLBACK_ADAPTER_KEY];
+}
+
+export {
+  Command,
+  ResponseEvent,
+  COMMAND_VERSIONS,
+  isCommandAvailable,
+  setCommandAvailable,
+  validateCommands,
+  sendMiniKitEvent,
+  isInWorldApp,
+  FallbackRequiredError,
+  CommandUnavailableError,
+  PartialExecutionError,
+  executeWithFallback,
+  setFallbackAdapter,
+  getFallbackAdapter
+};

package/build/{chunk-XO2TC2R4.js → chunk-MXMNPAOF.js}

@@ -1,6 +1,10 @@
 import {
   MiniKit
-} from "./chunk-363XY57O.js";
+} from "./chunk-7RB4UJBW.js";
+import {
+  isHexAddress,
+  isHexString
+} from "./chunk-2ADHLH4F.js";
 
 // src/provider.ts
 import { getAddress } from "viem";
@@ -23,12 +27,6 @@ function _clearAddress() {
 function rpcError(code, message) {
   return Object.assign(new Error(message), { code });
 }
-function isHexString(value) {
-  return /^0x[0-9a-fA-F]*$/.test(value);
-}
-function isAddressString(value) {
-  return /^0x[0-9a-fA-F]{40}$/.test(value);
-}
 function decodeHexToUtf8(hex) {
   const raw = hex.slice(2);
   if (raw.length % 2 !== 0) {
@@ -60,7 +58,7 @@ function extractPersonalSignMessage(params) {
     throw new Error("Missing personal_sign params");
   }
   const [first, second] = items;
-  const maybeMessage = typeof first === "string" && isAddressString(first) && typeof second === "string" ? second : first;
+  const maybeMessage = typeof first === "string" && isHexAddress(first) && typeof second === "string" ? second : first;
   if (typeof maybeMessage !== "string") {
     throw new Error("Invalid personal_sign message payload");
   }
@@ -72,7 +70,7 @@ function extractEthSignMessage(params) {
     throw new Error("Missing eth_sign params");
   }
   const [first, second] = items;
-  const maybeMessage = typeof second === "string" ? second : typeof first === "string" && !isAddressString(first) ? first : void 0;
+  const maybeMessage = typeof second === "string" ? second : typeof first === "string" && !isHexAddress(first) ? first : void 0;
   if (typeof maybeMessage !== "string") {
     throw new Error("Invalid eth_sign message payload");
   }
@@ -109,7 +107,7 @@ function normalizeRpcValue(value) {
 function extractTransactionParams(params) {
   const items = asArrayParams(params);
   const tx = items[0] ?? {};
-  if (typeof tx.to !== "string" || !isAddressString(tx.to)) {
+  if (typeof tx.to !== "string" || !isHexAddress(tx.to)) {
     throw new Error('Invalid transaction "to" address');
   }
   const chainId = typeof tx.chainId === "string" ? Number(tx.chainId) : typeof tx.chainId === "number" ? tx.chainId : void 0;

package/build/{chunk-4HSRVHAU.js → chunk-YPZEODWL.js}

@@ -3,7 +3,8 @@ import {
   createPublicClient,
   getContract,
   hashMessage,
-  http
+  http,
+  recoverMessageAddress
 } from "viem";
 import { worldchain } from "viem/chains";
 var PREAMBLE = " wants you to sign in with your Ethereum account:";
@@ -209,11 +210,31 @@ var verifySiweMessageV2 = async (payload, nonce, statement, requestId, userProvi
   if (!validateMessage(siweMessageData, nonce, statement, requestId)) {
     throw new Error("Validation failed");
   }
+  if (siweMessageData.address && siweMessageData.address.toLowerCase() !== address.toLowerCase()) {
+    throw new Error(
+      "Address mismatch: payload address does not match SIWE message address"
+    );
+  }
+  const expectedAddress = (siweMessageData.address ?? address).toLowerCase();
+  try {
+    const recoveredAddress = await recoverMessageAddress({
+      message,
+      signature
+    });
+    if (recoveredAddress.toLowerCase() === expectedAddress) {
+      return {
+        isValid: true,
+        siweMessageData
+      };
+    }
+  } catch {
+  }
   try {
+    const client = userProvider || createPublicClient({ chain: worldchain, transport: http() });
     const walletContract = getContract({
       address,
       abi: SAFE_CONTRACT_ABI,
-      client: userProvider || createPublicClient({ chain: worldchain, transport: http() })
+      client
     });
     const hashedMessage = hashMessage(message);
     const res = await walletContract.read.isValidSignature([

package/build/command-exports.cjs

@@ -264,6 +264,14 @@ var EventManager = class {
 };
 
 // src/commands/fallback.ts
+var PartialExecutionError = class extends Error {
+  constructor(message, submitted, cause) {
+    super(message);
+    this.name = "PartialExecutionError";
+    this.submitted = submitted;
+    this.cause = cause;
+  }
+};
 async function executeWithFallback(options) {
   const {
     command,
@@ -289,6 +297,9 @@ async function executeWithFallback(options) {
       const data = await wagmiFallback();
       return { data, executedWith: "wagmi" };
     } catch (error) {
+      if (error instanceof PartialExecutionError || error instanceof Error && error.name === "PartialExecutionError") {
+        throw error;
+      }
       console.warn(`Wagmi fallback for ${command} failed:`, error);
     }
   }
@@ -951,7 +962,6 @@ var validateSendTransactionPayload = (payload) => {
 
 // src/commands/send-transaction/index.ts
 var WORLD_CHAIN_ID = 480;
-var WAGMI_MULTI_TX_ERROR_MESSAGE = "Wagmi fallback does not support multi-transaction execution. Pass a single transaction, run inside World App for batching, or provide a custom fallback.";
 function resolveChainId(options) {
   return options.chainId;
 }
@@ -978,12 +988,6 @@ function normalizeSendTransactionOptions(options) {
 async function sendTransaction(options, ctx) {
   const normalizedOptions = normalizeSendTransactionOptions(options);
   const fallbackAdapter = getFallbackAdapter();
-  const isWagmiFallbackPath = !isInWorldApp() && Boolean(fallbackAdapter?.sendTransaction);
-  if (isWagmiFallbackPath && normalizedOptions.transactions.length > 1 && !options.fallback) {
-    throw new SendTransactionError("invalid_operation" /* InvalidOperation */, {
-      reason: WAGMI_MULTI_TX_ERROR_MESSAGE
-    });
-  }
   const result = await executeWithFallback({
     command: "send-transaction" /* SendTransaction */,
     nativeExecutor: () => nativeSendTransaction(normalizedOptions, ctx),
@@ -1064,23 +1068,16 @@ async function nativeSendTransaction(options, ctx) {
   };
 }
 async function adapterSendTransactionFallback(options) {
-  if (options.transactions.length > 1) {
-    throw new Error(WAGMI_MULTI_TX_ERROR_MESSAGE);
-  }
-  const firstTransaction = options.transactions[0];
-  if (!firstTransaction) {
-    throw new Error("At least one transaction is required");
-  }
   const fallbackAdapter = getFallbackAdapter();
   if (!fallbackAdapter?.sendTransaction) {
     throw new Error("Fallback adapter is not registered.");
   }
   const result = await fallbackAdapter.sendTransaction({
-    transaction: {
-      address: firstTransaction.to,
-      data: firstTransaction.data,
-      value: firstTransaction.value
-    },
+    transactions: options.transactions.map((tx) => ({
+      address: tx.to,
+      data: tx.data,
+      value: tx.value
+    })),
     chainId: options.chainId
   });
   return {

package/build/command-exports.js

@@ -1,12 +1,8 @@
 import {
   AttestationError,
   AttestationErrorCodes,
-  COMMAND_VERSIONS,
   ChatError,
   ChatErrorCodes,
-  Command,
-  CommandUnavailableError,
-  FallbackRequiredError,
   GetPermissionsError,
   GetPermissionsErrorCodes,
   MiniAppLaunchLocation,
@@ -19,7 +15,6 @@ import {
   Permission,
   RequestPermissionError,
   RequestPermissionErrorCodes,
-  ResponseEvent,
   SendHapticFeedbackError,
   SendHapticFeedbackErrorCodes,
   SendTransactionError,
@@ -46,23 +41,30 @@ import {
   closeMiniApp,
   getContacts,
   getPermissions,
-  isCommandAvailable,
-  isInWorldApp,
   pay,
   requestPermission,
   sendHapticFeedback,
-  sendMiniKitEvent,
   sendTransaction,
-  setCommandAvailable,
   share,
   shareContacts,
   signMessage,
   signTypedData,
   tokenToDecimals,
-  validateCommands,
   walletAuth
-} from "./chunk-7SC4LSCB.js";
-import "./chunk-4HSRVHAU.js";
+} from "./chunk-AH3WTRZY.js";
+import "./chunk-YPZEODWL.js";
+import {
+  COMMAND_VERSIONS,
+  Command,
+  CommandUnavailableError,
+  FallbackRequiredError,
+  ResponseEvent,
+  isCommandAvailable,
+  isInWorldApp,
+  sendMiniKitEvent,
+  setCommandAvailable,
+  validateCommands
+} from "./chunk-DZ2YRSIU.js";
 export {
   AttestationError,
   AttestationErrorCodes,