@worldcoin/minikit-js 2.0.1 → 2.0.3

package/build/chunk-2ADHLH4F.js

@@ -0,0 +1,14 @@
+// src/helpers/hex.ts
+var HEX_ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+var HEX_STRING_REGEX = /^0x[0-9a-fA-F]*$/;
+function isHexAddress(value) {
+  return typeof value === "string" && HEX_ADDRESS_REGEX.test(value);
+}
+function isHexString(value) {
+  return typeof value === "string" && HEX_STRING_REGEX.test(value);
+}
+
+export {
+  isHexAddress,
+  isHexString
+};

package/build/{chunk-6SCI6OTQ.js → chunk-5B6BPEWR.js}

@@ -1,19 +1,25 @@
 import {
+  isHexAddress,
+  isHexString
+} from "./chunk-2ADHLH4F.js";
+import {
+  WAGMI_CONFIG_KEY,
+  WAGMI_INSTALL_HOOK_KEY
+} from "./chunk-6E2XIIO6.js";
+import {
+  PartialExecutionError,
   setFallbackAdapter
-} from "./chunk-XHYUUG6Y.js";
+} from "./chunk-DZ2YRSIU.js";
 
 // src/commands/wagmi-fallback.ts
 var SIWE_NONCE_REGEX = /^[a-zA-Z0-9]{8,}$/;
-var WAGMI_KEY = "__minikit_wagmi_config__";
 function setWagmiConfig(config) {
-  globalThis[WAGMI_KEY] = config;
+  globalThis[WAGMI_CONFIG_KEY] = config;
   registerWagmiFallbacks();
 }
+globalThis[WAGMI_INSTALL_HOOK_KEY] = setWagmiConfig;
 function getWagmiConfig() {
-  return globalThis[WAGMI_KEY];
-}
-function hasWagmiConfig() {
-  return globalThis[WAGMI_KEY] !== void 0;
+  return globalThis[WAGMI_CONFIG_KEY];
 }
 function registerWagmiFallbacks() {
   setFallbackAdapter({
@@ -24,21 +30,9 @@ function registerWagmiFallbacks() {
   });
 }
 async function loadWagmiActions() {
-  console.log("[MiniKit WagmiFallback] loadWagmiActions:start", {
-    hasWindow: typeof window !== "undefined",
-    hasWagmiConfig: hasWagmiConfig()
-  });
   try {
-    const actions = await import(
-      /* webpackIgnore: true */
-      "wagmi/actions"
-    );
-    console.log("[MiniKit WagmiFallback] loadWagmiActions:success");
-    return actions;
+    return await import("wagmi/actions");
   } catch (error) {
-    console.log("[MiniKit WagmiFallback] loadWagmiActions:error", {
-      message: error instanceof Error ? error.message : String(error)
-    });
     const wrappedError = new Error(
       'Wagmi fallback requires the "wagmi" package. Install wagmi or provide a custom fallback.'
     );
@@ -48,10 +42,7 @@ async function loadWagmiActions() {
 }
 async function loadSiwe() {
   try {
-    return await import(
-      /* webpackIgnore: true */
-      "siwe"
-    );
+    return await import("siwe");
   } catch (error) {
     const wrappedError = new Error(
       'Wagmi walletAuth fallback requires the "siwe" package. Install siwe or provide a custom fallback.'
@@ -62,10 +53,7 @@ async function loadSiwe() {
 }
 async function checksumAddress(addr) {
   try {
-    const { getAddress } = await import(
-      /* webpackIgnore: true */
-      "viem"
-    );
+    const { getAddress } = await import("viem");
     return getAddress(addr);
   } catch {
     return addr;
@@ -78,7 +66,10 @@ async function ensureConnected(config) {
     (connection) => connection.accounts && connection.accounts.length > 0 && (isWorldApp || connection.connector?.id !== "worldApp")
   );
   if (existingConnection && existingConnection.accounts) {
-    return checksumAddress(existingConnection.accounts[0]);
+    return {
+      address: await checksumAddress(existingConnection.accounts[0]),
+      connector: existingConnection.connector
+    };
   }
   const connectors = config.connectors;
   if (!connectors || connectors.length === 0) {
@@ -99,7 +90,10 @@ async function ensureConnected(config) {
       const account = result.accounts[0];
       const address = typeof account === "string" ? account : account.address;
       if (address) {
-        return checksumAddress(address);
+        return {
+          address: await checksumAddress(address),
+          connector: selectedConnector
+        };
       }
     }
   } catch (error) {
@@ -113,20 +107,15 @@ async function ensureConnected(config) {
   throw new Error("Failed to connect wallet");
 }
 async function wagmiWalletAuth(params) {
-  console.log("[MiniKit WagmiFallback] walletAuth:start", {
-    hasWagmiConfig: hasWagmiConfig(),
-    nonceLength: params.nonce?.length ?? 0
-  });
   const config = getWagmiConfig();
   if (!config) {
-    console.log("[MiniKit WagmiFallback] walletAuth:error:no-config");
     throw new Error(
       "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
     );
   }
   const { signMessage } = await loadWagmiActions();
   const { SiweMessage } = await loadSiwe();
-  const address = await ensureConnected(config);
+  const { address, connector } = await ensureConnected(config);
   if (!SIWE_NONCE_REGEX.test(params.nonce)) {
     throw new Error(
       "Invalid nonce: must be alphanumeric and at least 8 characters (EIP-4361)"
@@ -144,7 +133,11 @@ async function wagmiWalletAuth(params) {
     expirationTime: params.expirationTime?.toISOString()
   });
   const message = siweMessage.prepareMessage();
-  const signature = await signMessage(config, { message });
+  const signature = await signMessage(config, {
+    connector,
+    account: address,
+    message
+  });
   return {
     address,
     message,
@@ -152,19 +145,16 @@ async function wagmiWalletAuth(params) {
   };
 }
 async function wagmiSignMessage(params) {
-  console.log("[MiniKit WagmiFallback] signMessage:start", {
-    hasWagmiConfig: hasWagmiConfig()
-  });
   const config = getWagmiConfig();
   if (!config) {
-    console.log("[MiniKit WagmiFallback] signMessage:error:no-config");
     throw new Error(
       "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
     );
   }
   const { signMessage } = await loadWagmiActions();
-  const address = await ensureConnected(config);
+  const { address, connector } = await ensureConnected(config);
   const signature = await signMessage(config, {
+    connector,
     account: address,
     message: params.message
   });
@@ -176,26 +166,22 @@ async function wagmiSignMessage(params) {
   };
 }
 async function wagmiSignTypedData(params) {
-  console.log("[MiniKit WagmiFallback] signTypedData:start", {
-    hasWagmiConfig: hasWagmiConfig(),
-    hasChainId: params.chainId !== void 0
-  });
   const config = getWagmiConfig();
   if (!config) {
-    console.log("[MiniKit WagmiFallback] signTypedData:error:no-config");
     throw new Error(
       "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
     );
   }
   const { getChainId, signTypedData, switchChain } = await loadWagmiActions();
-  const address = await ensureConnected(config);
+  const { address, connector } = await ensureConnected(config);
   if (params.chainId !== void 0) {
     const currentChainId = await getChainId(config);
     if (currentChainId !== params.chainId) {
-      await switchChain(config, { chainId: params.chainId });
+      await switchChain(config, { chainId: params.chainId, connector });
     }
   }
   const signature = await signTypedData(config, {
+    connector,
     account: address,
     types: params.types,
     primaryType: params.primaryType,
@@ -213,27 +199,59 @@ function isChainMismatchError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("does not match the target chain");
 }
-async function wagmiSendTransaction(params) {
-  console.log("[MiniKit WagmiFallback] sendTransaction:start", {
-    hasWagmiConfig: hasWagmiConfig(),
-    chainId: params.chainId,
-    hasData: Boolean(params.transaction.data)
+function validateBatch(transactions) {
+  return transactions.map((tx, i) => {
+    if (!isHexAddress(tx.address)) {
+      throw new Error(
+        `Transaction ${i + 1}: invalid address "${tx.address}". Must be a 0x-prefixed 20-byte hex string.`
+      );
+    }
+    if (tx.data !== void 0 && !isHexString(tx.data)) {
+      throw new Error(
+        `Transaction ${i + 1}: invalid data "${tx.data}". Must be a 0x-prefixed hex string.`
+      );
+    }
+    let value;
+    if (tx.value !== void 0 && tx.value !== "") {
+      try {
+        value = BigInt(tx.value);
+      } catch {
+        throw new Error(
+          `Transaction ${i + 1}: invalid value "${tx.value}". Must be a decimal or hex string parseable as BigInt.`
+        );
+      }
+      if (value < 0n) {
+        throw new Error(
+          `Transaction ${i + 1}: value cannot be negative (got "${tx.value}").`
+        );
+      }
+    }
+    return {
+      to: tx.address,
+      ...tx.data !== void 0 ? { data: tx.data } : {},
+      ...value !== void 0 ? { value } : {}
+    };
   });
+}
+async function wagmiSendTransaction(params) {
+  if (params.transactions.length === 0) {
+    throw new Error("At least one transaction is required");
+  }
+  const normalizedTxs = validateBatch(params.transactions);
   const config = getWagmiConfig();
   if (!config) {
-    console.log("[MiniKit WagmiFallback] sendTransaction:error:no-config");
     throw new Error(
       "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
     );
   }
   const { getChainId, getWalletClient, sendTransaction, switchChain } = await loadWagmiActions();
-  await ensureConnected(config);
+  const { address, connector } = await ensureConnected(config);
   const targetChainId = params.chainId ?? config.chains?.[0]?.id;
   const ensureTargetChain = async () => {
     if (targetChainId === void 0) return;
     const currentChainId = await getChainId(config);
     if (currentChainId !== targetChainId) {
-      await switchChain(config, { chainId: targetChainId });
+      await switchChain(config, { chainId: targetChainId, connector });
     }
     const walletClient = await getWalletClient(config);
     const providerChainId = walletClient ? await walletClient.getChainId() : await getChainId(config);
@@ -244,27 +262,41 @@ async function wagmiSendTransaction(params) {
     }
   };
   await ensureTargetChain();
-  let transactionHash;
-  try {
-    transactionHash = await sendTransaction(config, {
+  const sendWithChainRetry = async (tx) => {
+    const send = () => sendTransaction(config, {
+      connector,
+      account: address,
       chainId: targetChainId,
-      to: params.transaction.address,
-      data: params.transaction.data,
-      value: params.transaction.value ? BigInt(params.transaction.value) : void 0
+      to: tx.to,
+      data: tx.data,
+      value: tx.value
     });
-  } catch (error) {
-    if (targetChainId === void 0 || !isChainMismatchError(error)) {
+    try {
+      return await send();
+    } catch (error) {
+      if (targetChainId !== void 0 && isChainMismatchError(error)) {
+        await ensureTargetChain();
+        return await send();
+      }
+      throw error;
+    }
+  };
+  const submitted = [];
+  for (let i = 0; i < normalizedTxs.length; i++) {
+    try {
+      submitted.push(await sendWithChainRetry(normalizedTxs[i]));
+    } catch (error) {
+      if (submitted.length > 0) {
+        throw new PartialExecutionError(
+          `Transaction ${i + 1}/${normalizedTxs.length} failed after ${submitted.length} tx(s) were already submitted. Resolve manually.`,
+          submitted,
+          error
+        );
+      }
       throw error;
     }
-    await ensureTargetChain();
-    transactionHash = await sendTransaction(config, {
-      chainId: targetChainId,
-      to: params.transaction.address,
-      data: params.transaction.data,
-      value: params.transaction.value ? BigInt(params.transaction.value) : void 0
-    });
   }
-  return { transactionHash };
+  return { transactionHash: submitted[submitted.length - 1] };
 }
 
 export {

package/build/chunk-6E2XIIO6.js

@@ -0,0 +1,8 @@
+// src/global-keys.ts
+var WAGMI_CONFIG_KEY = "__minikit_wagmi_config__";
+var WAGMI_INSTALL_HOOK_KEY = "__minikit_install_wagmi_fallback__";
+
+export {
+  WAGMI_CONFIG_KEY,
+  WAGMI_INSTALL_HOOK_KEY
+};

package/build/{chunk-MOORQBWF.js → chunk-7RB4UJBW.js}

@@ -5,19 +5,21 @@ import {
   chat,
   closeMiniApp,
   getPermissions,
-  isInWorldApp,
   pay,
   requestPermission,
   sendHapticFeedback,
-  sendMiniKitEvent,
   sendTransaction,
   share,
   shareContacts,
   signMessage,
   signTypedData,
-  validateCommands,
   walletAuth
-} from "./chunk-XHYUUG6Y.js";
+} from "./chunk-AH3WTRZY.js";
+import {
+  isInWorldApp,
+  sendMiniKitEvent,
+  validateCommands
+} from "./chunk-DZ2YRSIU.js";
 
 // src/helpers/microphone.ts
 var microphoneSetupDone = false;

package/build/{chunk-XHYUUG6Y.js → chunk-AH3WTRZY.js}

@@ -1,135 +1,14 @@
 import {
   generateSiweMessage
-} from "./chunk-IYL4VCWR.js";
-
-// 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;
-  }
-};
+} from "./chunk-YPZEODWL.js";
+import {
+  COMMAND_VERSIONS,
+  CommandUnavailableError,
+  executeWithFallback,
+  getFallbackAdapter,
+  isCommandAvailable,
+  sendMiniKitEvent
+} from "./chunk-DZ2YRSIU.js";
 
 // src/commands/attestation/types.ts
 var AttestationErrorCodes = /* @__PURE__ */ ((AttestationErrorCodes2) => {
@@ -197,57 +76,6 @@ var EventManager = class {
   }
 };
 
-// src/commands/fallback.ts
-async function executeWithFallback(options) {
-  const {
-    command,
-    nativeExecutor,
-    wagmiFallback,
-    customFallback,
-    requiresFallback = false
-  } = options;
-  const inWorldApp = isInWorldApp();
-  const commandAvailable = isCommandAvailable(command);
-  let nativeError;
-  if (inWorldApp && commandAvailable) {
-    try {
-      const data = await nativeExecutor();
-      return { data, executedWith: "minikit" };
-    } catch (error) {
-      nativeError = error;
-      console.warn(`Native ${command} failed, attempting fallback:`, error);
-    }
-  }
-  if (!inWorldApp && wagmiFallback) {
-    try {
-      const data = await wagmiFallback();
-      return { data, executedWith: "wagmi" };
-    } catch (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/attestation/index.ts
 async function attestation(options, ctx) {
   const result = await executeWithFallback({
@@ -802,15 +630,6 @@ var SendTransactionError = class extends Error {
   }
 };
 
-// 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];
-}
-
 // src/commands/send-transaction/validate.ts
 var isValidHex = (str) => {
   return /^0x[0-9A-Fa-f]+$/.test(str);
@@ -871,7 +690,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;
 }
@@ -898,12 +716,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),
@@ -984,23 +796,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 {
@@ -1542,7 +1347,8 @@ async function nativeWalletAuth(options, ctx) {
   return {
     address: finalPayload.address,
     message: finalPayload.message,
-    signature: finalPayload.signature
+    signature: finalPayload.signature,
+    version: finalPayload.version
   };
 }
 
@@ -1572,16 +1378,6 @@ var MiniKitInstallErrorMessage = {
 };
 
 export {
-  Command,
-  ResponseEvent,
-  COMMAND_VERSIONS,
-  isCommandAvailable,
-  setCommandAvailable,
-  validateCommands,
-  sendMiniKitEvent,
-  isInWorldApp,
-  FallbackRequiredError,
-  CommandUnavailableError,
   EventManager,
   AttestationErrorCodes,
   AttestationError,
@@ -1608,7 +1404,6 @@ export {
   SendHapticFeedbackErrorCodes,
   SendHapticFeedbackError,
   sendHapticFeedback,
-  setFallbackAdapter,
   SendTransactionErrorCodes,
   SendTransactionErrorMessage,
   WORLD_APP_FEATURES,