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

package/build/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -37,9 +27,10 @@ module.exports = __toCommonJS(src_exports);
 
 // src/commands/types.ts
 var COMMAND_VERSIONS = {
+  ["attestation" /* Attestation */]: 1,
   ["pay" /* Pay */]: 1,
   ["wallet-auth" /* WalletAuth */]: 2,
-  ["send-transaction" /* SendTransaction */]: 1,
+  ["send-transaction" /* SendTransaction */]: 2,
   ["sign-message" /* SignMessage */]: 1,
   ["sign-typed-data" /* SignTypedData */]: 1,
   ["share-contacts" /* ShareContacts */]: 1,
@@ -47,9 +38,11 @@ var COMMAND_VERSIONS = {
   ["get-permissions" /* GetPermissions */]: 1,
   ["send-haptic-feedback" /* SendHapticFeedback */]: 1,
   ["share" /* Share */]: 1,
-  ["chat" /* Chat */]: 1
+  ["chat" /* Chat */]: 1,
+  ["close-miniapp" /* CloseMiniApp */]: 1
 };
 var commandAvailability = {
+  ["attestation" /* Attestation */]: false,
   ["pay" /* Pay */]: false,
   ["wallet-auth" /* WalletAuth */]: false,
   ["send-transaction" /* SendTransaction */]: false,
@@ -60,7 +53,8 @@ var commandAvailability = {
   ["get-permissions" /* GetPermissions */]: false,
   ["send-haptic-feedback" /* SendHapticFeedback */]: false,
   ["share" /* Share */]: false,
-  ["chat" /* Chat */]: false
+  ["chat" /* Chat */]: false,
+  ["close-miniapp" /* CloseMiniApp */]: false
 };
 function isCommandAvailable(command) {
   return commandAvailability[command] ?? false;
@@ -132,6 +126,8 @@ var CommandUnavailableError = class extends Error {
 var EventManager = class {
   constructor() {
     this.listeners = {
+      ["miniapp-attestation" /* MiniAppAttestation */]: () => {
+      },
       ["miniapp-payment" /* MiniAppPayment */]: () => {
       },
       ["miniapp-wallet-auth" /* MiniAppWalletAuth */]: () => {
@@ -175,191 +171,6 @@ var EventManager = class {
   }
 };
 
-// src/commands/wagmi-fallback.ts
-var SIWE_NONCE_REGEX = /^[a-zA-Z0-9]{8,}$/;
-var WAGMI_KEY = "__minikit_wagmi_config__";
-function getWagmiConfig() {
-  return globalThis[WAGMI_KEY];
-}
-function hasWagmiConfig() {
-  return globalThis[WAGMI_KEY] !== void 0;
-}
-async function ensureConnected(config) {
-  const { connect, getConnections } = await import("wagmi/actions");
-  const isWorldApp = typeof window !== "undefined" && Boolean(window.WorldApp);
-  const existingConnection = getConnections(config).find(
-    (connection) => connection.accounts && connection.accounts.length > 0 && (isWorldApp || connection.connector?.id !== "worldApp")
-  );
-  if (existingConnection && existingConnection.accounts) {
-    return existingConnection.accounts[0];
-  }
-  const connectors = config.connectors;
-  if (!connectors || connectors.length === 0) {
-    throw new Error("No Wagmi connectors configured");
-  }
-  const candidateConnectors = isWorldApp ? connectors : connectors.filter(
-    (connector) => connector.id !== "worldApp"
-  );
-  if (!isWorldApp && candidateConnectors.length === 0) {
-    throw new Error(
-      "No web Wagmi connectors configured. Add a web connector (e.g. injected or walletConnect) after worldApp()."
-    );
-  }
-  const selectedConnector = candidateConnectors[0];
-  try {
-    const result = await connect(config, { connector: selectedConnector });
-    if (result.accounts.length > 0) {
-      const account = result.accounts[0];
-      const address = typeof account === "string" ? account : account.address;
-      if (address) {
-        return address;
-      }
-    }
-  } catch (error) {
-    const connectorId = selectedConnector.id ?? "unknown";
-    const wrappedError = new Error(
-      `Failed to connect with connector "${connectorId}". Reorder connectors to change the default connector.`
-    );
-    wrappedError.cause = error;
-    throw wrappedError;
-  }
-  throw new Error("Failed to connect wallet");
-}
-async function wagmiWalletAuth(params) {
-  const config = getWagmiConfig();
-  if (!config) {
-    throw new Error(
-      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
-    );
-  }
-  const { signMessage: signMessage2 } = await import("wagmi/actions");
-  const { SiweMessage } = await import("siwe");
-  const address = 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)"
-    );
-  }
-  const siweMessage = new SiweMessage({
-    domain: typeof window !== "undefined" ? window.location.host : "localhost",
-    address,
-    statement: params.statement,
-    uri: typeof window !== "undefined" ? window.location.origin : "http://localhost",
-    version: "1",
-    chainId: 480,
-    // World Chain
-    nonce: params.nonce,
-    expirationTime: params.expirationTime?.toISOString()
-  });
-  const message = siweMessage.prepareMessage();
-  const signature = await signMessage2(config, { message });
-  return {
-    address,
-    message,
-    signature
-  };
-}
-async function wagmiSignMessage(params) {
-  const config = getWagmiConfig();
-  if (!config) {
-    throw new Error(
-      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
-    );
-  }
-  const { signMessage: signMessage2 } = await import("wagmi/actions");
-  const address = await ensureConnected(config);
-  const signature = await signMessage2(config, {
-    account: address,
-    message: params.message
-  });
-  return {
-    status: "success",
-    version: 1,
-    signature,
-    address
-  };
-}
-async function wagmiSignTypedData(params) {
-  const config = getWagmiConfig();
-  if (!config) {
-    throw new Error(
-      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
-    );
-  }
-  const { getChainId, signTypedData: signTypedData2, switchChain } = await import("wagmi/actions");
-  const address = await ensureConnected(config);
-  if (params.chainId !== void 0) {
-    const currentChainId = await getChainId(config);
-    if (currentChainId !== params.chainId) {
-      await switchChain(config, { chainId: params.chainId });
-    }
-  }
-  const signature = await signTypedData2(config, {
-    account: address,
-    types: params.types,
-    primaryType: params.primaryType,
-    domain: params.domain,
-    message: params.message
-  });
-  return {
-    status: "success",
-    version: 1,
-    signature,
-    address
-  };
-}
-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) {
-  const config = getWagmiConfig();
-  if (!config) {
-    throw new Error(
-      "Wagmi config not available. Pass wagmiConfig to MiniKitProvider."
-    );
-  }
-  const { getChainId, getWalletClient, sendTransaction: sendTransaction2, switchChain } = await import("wagmi/actions");
-  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 });
-    }
-    const walletClient = await getWalletClient(config);
-    const providerChainId = walletClient ? await walletClient.getChainId() : await getChainId(config);
-    if (providerChainId !== targetChainId) {
-      throw new Error(
-        `Wallet network mismatch: expected chain ${targetChainId}, got ${providerChainId}. Please switch networks in your wallet and retry.`
-      );
-    }
-  };
-  await ensureTargetChain();
-  let transactionHash;
-  try {
-    transactionHash = await sendTransaction2(config, {
-      chainId: targetChainId,
-      to: params.transaction.address,
-      data: params.transaction.data,
-      value: params.transaction.value ? BigInt(params.transaction.value) : void 0
-    });
-  } catch (error) {
-    if (targetChainId === void 0 || !isChainMismatchError(error)) {
-      throw error;
-    }
-    await ensureTargetChain();
-    transactionHash = await sendTransaction2(config, {
-      chainId: targetChainId,
-      to: params.transaction.address,
-      data: params.transaction.data,
-      value: params.transaction.value ? BigInt(params.transaction.value) : void 0
-    });
-  }
-  return { transactionHash };
-}
-
 // src/commands/fallback.ts
 async function executeWithFallback(options) {
   const {
@@ -381,7 +192,7 @@ async function executeWithFallback(options) {
       console.warn(`Native ${command} failed, attempting fallback:`, error);
     }
   }
-  if (!inWorldApp && wagmiFallback && hasWagmiConfig()) {
+  if (!inWorldApp && wagmiFallback) {
     try {
       const data = await wagmiFallback();
       return { data, executedWith: "wagmi" };
@@ -389,7 +200,7 @@ async function executeWithFallback(options) {
       console.warn(`Wagmi fallback for ${command} failed:`, error);
     }
   }
-  if (customFallback) {
+  if (!inWorldApp && customFallback) {
     const data = await customFallback();
     return { data, executedWith: "fallback" };
   }
@@ -411,6 +222,67 @@ function determineFallbackReason(command) {
   return "commandNotSupported";
 }
 
+// src/commands/attestation/types.ts
+var AttestationError = class extends Error {
+  constructor(error_code) {
+    super(`Attestation failed: ${error_code}`);
+    this.error_code = error_code;
+    this.name = "AttestationError";
+  }
+};
+
+// src/commands/attestation/index.ts
+async function attestation(options, ctx) {
+  const result = await executeWithFallback({
+    command: "attestation" /* Attestation */,
+    nativeExecutor: () => nativeAttestation(options, ctx),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeAttestation(options, ctx) {
+  if (!ctx) {
+    ctx = { events: new EventManager(), state: { deviceProperties: {} } };
+  }
+  if (typeof window === "undefined" || !isCommandAvailable("attestation" /* Attestation */)) {
+    throw new Error(
+      "'attestation' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  if (!options.requestHash || options.requestHash.length === 0) {
+    throw new Error("'attestation' command requires a non-empty requestHash");
+  }
+  const payload = await new Promise(
+    (resolve, reject) => {
+      try {
+        ctx.events.subscribe("miniapp-attestation" /* MiniAppAttestation */, (response) => {
+          ctx.events.unsubscribe("miniapp-attestation" /* MiniAppAttestation */);
+          resolve(response);
+        });
+        sendMiniKitEvent({
+          command: "attestation" /* Attestation */,
+          version: COMMAND_VERSIONS["attestation" /* Attestation */],
+          payload: {
+            request_hash: options.requestHash
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    }
+  );
+  if (payload.status === "error") {
+    throw new AttestationError(payload.error_code);
+  }
+  return payload;
+}
+
 // src/commands/chat/types.ts
 var ChatError = class extends Error {
   constructor(error_code) {
@@ -472,6 +344,38 @@ async function nativeChat(options, ctx) {
   return payload;
 }
 
+// src/commands/close-miniapp/index.ts
+async function closeMiniApp(options = {}, _ctx) {
+  const result = await executeWithFallback({
+    command: "close-miniapp" /* CloseMiniApp */,
+    nativeExecutor: () => nativeCloseMiniApp(),
+    customFallback: options.fallback
+  });
+  if (result.executedWith === "fallback") {
+    return { executedWith: "fallback", data: result.data };
+  }
+  return {
+    executedWith: "minikit",
+    data: result.data
+  };
+}
+async function nativeCloseMiniApp() {
+  if (typeof window === "undefined" || !isCommandAvailable("close-miniapp" /* CloseMiniApp */)) {
+    throw new Error(
+      "'closeMiniApp' command is unavailable. Check MiniKit.install() or update the app version"
+    );
+  }
+  sendMiniKitEvent({
+    command: "close-miniapp" /* CloseMiniApp */,
+    version: COMMAND_VERSIONS["close-miniapp" /* CloseMiniApp */],
+    payload: {}
+  });
+  return {
+    status: "success",
+    version: COMMAND_VERSIONS["close-miniapp" /* CloseMiniApp */]
+  };
+}
+
 // src/commands/get-permissions/types.ts
 var GetPermissionsError = class extends Error {
   constructor(error_code) {
@@ -740,8 +644,11 @@ async function nativeSendHapticFeedback(options, ctx) {
   return payload;
 }
 
-// src/commands/send-transaction/index.ts
-var import_viem = require("viem");
+// src/commands/fallback-adapter-registry.ts
+var FALLBACK_ADAPTER_KEY = "__minikit_fallback_adapter__";
+function getFallbackAdapter() {
+  return globalThis[FALLBACK_ADAPTER_KEY];
+}
 
 // src/commands/send-transaction/types.ts
 var SendTransactionError = class extends Error {
@@ -757,16 +664,6 @@ var SendTransactionError = class extends Error {
 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;
@@ -779,6 +676,20 @@ var processPayload = (payload) => {
   }
   if (typeof payload === "object") {
     const result = { ...payload };
+    if ("chainId" in result && result.chainId !== void 0) {
+      if (typeof result.chainId === "string") {
+        const parsed = Number(result.chainId);
+        if (Number.isFinite(parsed)) {
+          result.chainId = parsed;
+        }
+      } else if (typeof result.chainId === "bigint") {
+        const parsed = Number(result.chainId);
+        if (!Number.isSafeInteger(parsed)) {
+          throw new Error(`Invalid chainId: ${String(result.chainId)}`);
+        }
+        result.chainId = parsed;
+      }
+    }
     if ("value" in result && result.value !== void 0) {
       if (typeof result.value !== "string") {
         result.value = String(result.value);
@@ -795,6 +706,7 @@ var processPayload = (payload) => {
     }
     for (const key in result) {
       if (Object.prototype.hasOwnProperty.call(result, key)) {
+        if (key === "chainId") continue;
         result[key] = processPayload(result[key]);
       }
     }
@@ -803,37 +715,48 @@ var processPayload = (payload) => {
   return payload;
 };
 var validateSendTransactionPayload = (payload) => {
-  if (payload.formatPayload) {
-    const formattedPayload = processPayload(payload);
-    formattedPayload.transaction = formattedPayload.transaction.map((tx) => {
-      if ("args" in tx && tx.args !== void 0) {
-        const args = objectValuesToArrayRecursive(tx.args);
-        return {
-          ...tx,
-          args
-        };
-      }
-      return tx;
-    });
-    return formattedPayload;
-  }
-  return payload;
+  return processPayload(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;
+}
+function resolveTransactions(options) {
+  if (options.transactions.length === 0) {
+    throw new SendTransactionError("input_error" /* InputError */, {
+      reason: "At least one transaction is required. Use `transactions: [{ to, data, value }]`."
+    });
+  }
+  return options.transactions;
+}
+function normalizeSendTransactionOptions(options) {
+  const chainId = resolveChainId(options);
+  if (chainId !== WORLD_CHAIN_ID) {
+    throw new SendTransactionError("invalid_operation" /* InvalidOperation */, {
+      reason: `World App only supports World Chain (chainId: ${WORLD_CHAIN_ID})`
+    });
+  }
+  return {
+    transactions: resolveTransactions(options),
+    chainId
+  };
+}
 async function sendTransaction(options, ctx) {
-  const isWagmiFallbackPath = !isInWorldApp() && hasWagmiConfig();
-  if (isWagmiFallbackPath && options.transaction.length > 1 && !options.fallback) {
+  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(options, ctx),
-    wagmiFallback: () => wagmiSendTransactionAdapter(options),
+    nativeExecutor: () => nativeSendTransaction(normalizedOptions, ctx),
+    wagmiFallback: fallbackAdapter?.sendTransaction ? () => adapterSendTransactionFallback(normalizedOptions) : void 0,
     customFallback: options.fallback
   });
   if (result.executedWith === "fallback") {
@@ -859,15 +782,22 @@ async function nativeSendTransaction(options, ctx) {
       "'sendTransaction' command is unavailable. Check MiniKit.install() or update the app version"
     );
   }
-  if (options.chainId !== void 0 && options.chainId !== WORLD_CHAIN_ID) {
+  if (options.chainId !== WORLD_CHAIN_ID) {
     throw new Error(
       `World App only supports World Chain (chainId: ${WORLD_CHAIN_ID})`
     );
   }
+  const commandInput = window.WorldApp?.supported_commands.find(
+    (command) => command.name === "send-transaction" /* SendTransaction */
+  );
+  if (commandInput && !commandInput.supported_versions.includes(
+    COMMAND_VERSIONS["send-transaction" /* SendTransaction */]
+  )) {
+    throw new CommandUnavailableError("send-transaction" /* SendTransaction */, "oldAppVersion");
+  }
   const input = {
-    transaction: options.transaction,
-    permit2: options.permit2,
-    formatPayload: options.formatPayload !== false
+    transactions: options.transactions,
+    chainId: options.chainId
   };
   const validatedPayload = validateSendTransactionPayload(input);
   const finalPayload = await new Promise(
@@ -893,71 +823,43 @@ async function nativeSendTransaction(options, ctx) {
       finalPayload.details
     );
   }
+  const successPayload = finalPayload;
   return {
-    transactionHash: null,
-    userOpHash: finalPayload.userOpHash ?? null,
-    mini_app_id: finalPayload.mini_app_id ?? null,
+    userOpHash: String(successPayload.userOpHash ?? ""),
     status: finalPayload.status,
     version: finalPayload.version,
-    transactionId: finalPayload.transaction_id,
-    reference: finalPayload.reference,
-    from: finalPayload.from,
-    chain: finalPayload.chain,
-    timestamp: finalPayload.timestamp,
-    // Deprecated aliases
-    transaction_id: finalPayload.transaction_id,
-    transaction_status: "submitted"
+    from: String(successPayload.from ?? ""),
+    timestamp: String(successPayload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString())
   };
 }
-async function wagmiSendTransactionAdapter(options) {
-  if (options.transaction.length > 1) {
+async function adapterSendTransactionFallback(options) {
+  if (options.transactions.length > 1) {
     throw new Error(WAGMI_MULTI_TX_ERROR_MESSAGE);
   }
-  if (options.permit2 && options.permit2.length > 0) {
-    console.warn(
-      "Permit2 signature is not automatically supported via Wagmi fallback. Transactions will execute without permit2."
-    );
-  }
-  const transactions = options.transaction.map((tx) => ({
-    address: tx.address,
-    // Encode the function call data
-    data: encodeTransactionData(tx),
-    value: tx.value
-  }));
-  const firstTransaction = transactions[0];
+  const firstTransaction = options.transactions[0];
   if (!firstTransaction) {
     throw new Error("At least one transaction is required");
   }
-  const result = await wagmiSendTransaction({
-    transaction: firstTransaction,
+  const fallbackAdapter = getFallbackAdapter();
+  if (!fallbackAdapter?.sendTransaction) {
+    throw new Error("Fallback adapter is not registered.");
+  }
+  const result = await fallbackAdapter.sendTransaction({
+    transaction: {
+      address: firstTransaction.to,
+      data: firstTransaction.data,
+      value: firstTransaction.value
+    },
     chainId: options.chainId
   });
   return {
-    transactionHash: result.transactionHash,
-    userOpHash: null,
-    mini_app_id: null,
+    userOpHash: result.transactionHash,
     status: "success",
-    version: 1,
-    transactionId: null,
-    reference: null,
-    from: null,
-    chain: null,
-    timestamp: null
+    version: COMMAND_VERSIONS["send-transaction" /* SendTransaction */],
+    from: "",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function encodeTransactionData(tx) {
-  if (tx.data) {
-    return tx.data;
-  }
-  if (!tx.abi || !tx.functionName) {
-    throw new Error("Transaction requires `data` or `abi` + `functionName`.");
-  }
-  return (0, import_viem.encodeFunctionData)({
-    abi: tx.abi,
-    functionName: tx.functionName,
-    args: tx.args ?? []
-  });
-}
 
 // src/commands/share/format.ts
 var MAX_FILES = 10;
@@ -1176,12 +1078,13 @@ var SignMessageError = class extends Error {
 
 // src/commands/sign-message/index.ts
 async function signMessage(options, ctx) {
+  const fallbackAdapter = getFallbackAdapter();
   const result = await executeWithFallback({
     command: "sign-message" /* SignMessage */,
     nativeExecutor: () => nativeSignMessage(options, ctx),
-    wagmiFallback: () => wagmiSignMessage({
+    wagmiFallback: fallbackAdapter?.signMessage ? () => fallbackAdapter.signMessage({
       message: options.message
-    }),
+    }) : void 0,
     customFallback: options.fallback
   });
   if (result.executedWith === "fallback") {
@@ -1241,16 +1144,17 @@ var SignTypedDataError = class extends Error {
 
 // src/commands/sign-typed-data/index.ts
 async function signTypedData(options, ctx) {
+  const fallbackAdapter = getFallbackAdapter();
   const result = await executeWithFallback({
     command: "sign-typed-data" /* SignTypedData */,
     nativeExecutor: () => nativeSignTypedData(options, ctx),
-    wagmiFallback: () => wagmiSignTypedData({
+    wagmiFallback: fallbackAdapter?.signTypedData ? () => fallbackAdapter.signTypedData({
       types: options.types,
       primaryType: options.primaryType,
       message: options.message,
       domain: options.domain,
       chainId: options.chainId
-    }),
+    }) : void 0,
     customFallback: options.fallback
   });
   if (result.executedWith === "fallback") {
@@ -1307,7 +1211,7 @@ async function nativeSignTypedData(options, ctx) {
 }
 
 // src/commands/wallet-auth/siwe.ts
-var import_viem2 = require("viem");
+var import_viem = require("viem");
 var import_chains = require("viem/chains");
 var generateSiweMessage = (siweMessageData) => {
   let siweMessage = "";
@@ -1366,7 +1270,7 @@ var WalletAuthError = class extends Error {
 };
 
 // src/commands/wallet-auth/validate.ts
-var SIWE_NONCE_REGEX2 = /^[a-zA-Z0-9]+$/;
+var SIWE_NONCE_REGEX = /^[a-zA-Z0-9]+$/;
 var validateWalletAuthCommandInput = (params) => {
   if (!params.nonce) {
     return { valid: false, message: "'nonce' is required" };
@@ -1374,7 +1278,7 @@ var validateWalletAuthCommandInput = (params) => {
   if (params.nonce.length < 8) {
     return { valid: false, message: "'nonce' must be at least 8 characters" };
   }
-  if (!SIWE_NONCE_REGEX2.test(params.nonce)) {
+  if (!SIWE_NONCE_REGEX.test(params.nonce)) {
     return {
       valid: false,
       message: "'nonce' must be alphanumeric (letters and numbers only)"
@@ -1397,14 +1301,15 @@ var validateWalletAuthCommandInput = (params) => {
 
 // src/commands/wallet-auth/index.ts
 async function walletAuth(options, ctx) {
+  const fallbackAdapter = getFallbackAdapter();
   const result = await executeWithFallback({
     command: "wallet-auth" /* WalletAuth */,
     nativeExecutor: () => nativeWalletAuth(options, ctx),
-    wagmiFallback: () => wagmiWalletAuth({
+    wagmiFallback: fallbackAdapter?.walletAuth ? () => fallbackAdapter.walletAuth({
       nonce: options.nonce,
       statement: options.statement,
       expirationTime: options.expirationTime
-    }),
+    }) : void 0,
     customFallback: options.fallback
   });
   if (result.executedWith === "fallback") {
@@ -1658,11 +1563,10 @@ var _MiniKit = class _MiniKit {
    * ```typescript
    * const result = await MiniKit.sendTransaction({
    *   chainId: 480,
-   *   transaction: [{
-   *     address: '0x...',
-   *     abi: ContractABI,
-   *     functionName: 'mint',
-   *     args: [],
+   *   transactions: [{
+   *     to: '0x...',
+   *     data: '0x...',
+   *     value: '0x0',
    *   }],
    * });
    * ```
@@ -1787,6 +1691,26 @@ var _MiniKit = class _MiniKit {
     }
     return sendHapticFeedback(options, this.getContext());
   }
+  /**
+   * Request app attestation token for a request hash
+   */
+  static attestation(options) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.attestation(options);
+    }
+    return attestation(options, this.getContext());
+  }
+  /**
+   * Close the mini app
+   */
+  static closeMiniApp(options = {}) {
+    const active = this.getActiveMiniKit();
+    if (active !== this) {
+      return active.closeMiniApp(options);
+    }
+    return closeMiniApp(options, this.getContext());
+  }
   // ============================================================================
   // Public State Accessors
   // ============================================================================
@@ -1965,6 +1889,8 @@ var _MiniKit = class _MiniKit {
    * - `MiniKit.commands.getPermissions()` → `await MiniKit.getPermissions()`
    * - `MiniKit.commands.requestPermission(payload)` → `await MiniKit.requestPermission(input)`
    * - `MiniKit.commands.sendHapticFeedback(payload)` → `await MiniKit.sendHapticFeedback(input)`
+   * - `MiniKit.commands.attestation(payload)` → `await MiniKit.attestation(options)`
+   * - `MiniKit.commands.closeMiniApp()` → `await MiniKit.closeMiniApp()`
    */
   static get commands() {
     throw new Error(
@@ -2052,13 +1978,18 @@ _MiniKit.showProfileCard = (username, walletAddress) => {
 var MiniKit = _MiniKit;
 
 // src/provider.ts
+var import_viem2 = require("viem");
 function _getAddress() {
   if (typeof window === "undefined") return void 0;
   return window.__worldapp_eip1193_address__;
 }
 function _setAddress(addr) {
   if (typeof window === "undefined") return;
-  window.__worldapp_eip1193_address__ = addr;
+  try {
+    window.__worldapp_eip1193_address__ = (0, import_viem2.getAddress)(addr);
+  } catch {
+    window.__worldapp_eip1193_address__ = addr;
+  }
 }
 function rpcError(code, message) {
   return Object.assign(new Error(message), { code });
@@ -2178,16 +2109,19 @@ function createProvider() {
   }
   let authInFlight;
   async function doAuth() {
-    if (!MiniKit.isInWorldApp()) {
-      throw rpcError(4900, "World App provider only works inside World App");
+    if (!MiniKit.isInWorldApp() || !MiniKit.isInstalled()) {
+      throw rpcError(
+        4900,
+        "World App provider only works inside World App and must be installed"
+      );
     }
     try {
       const result = await MiniKit.walletAuth({
         nonce: crypto.randomUUID().replace(/-/g, ""),
         statement: "Sign in with World App"
       });
-      const addr = result.data.address;
-      _setAddress(addr);
+      _setAddress(result.data.address);
+      const addr = _getAddress();
       emit("accountsChanged", [addr]);
       return [addr];
     } catch (e) {
@@ -2257,18 +2191,21 @@ function createProvider() {
         }
         case "eth_sendTransaction": {
           const tx = extractTransactionParams(params);
+          if (tx.chainId !== void 0 && tx.chainId !== 480) {
+            throw rpcError(4902, "World App only supports World Chain (480)");
+          }
           try {
             const result = await MiniKit.sendTransaction({
-              ...tx.chainId !== void 0 ? { chainId: tx.chainId } : {},
-              transaction: [
+              chainId: tx.chainId ?? 480,
+              transactions: [
                 {
-                  address: tx.to,
+                  to: tx.to,
                   ...tx.data && tx.data !== "0x" ? { data: tx.data } : {},
                   value: tx.value
                 }
               ]
             });
-            return result.data.transactionId;
+            return result.data.userOpHash;
           } catch (e) {
             throw rpcError(4001, `Send transaction failed: ${e.message}`);
           }