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

package/build/connector/index.cjs

@@ -34,11 +34,21 @@ __export(connector_exports, {
 });
 module.exports = __toCommonJS(connector_exports);
 
+// 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/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;
+  registerWagmiFallbacks();
 }
 function getWagmiConfig() {
   return globalThis[WAGMI_KEY];
@@ -46,14 +56,70 @@ function getWagmiConfig() {
 function hasWagmiConfig() {
   return globalThis[WAGMI_KEY] !== void 0;
 }
+function registerWagmiFallbacks() {
+  setFallbackAdapter({
+    walletAuth: wagmiWalletAuth,
+    signMessage: wagmiSignMessage,
+    signTypedData: wagmiSignTypedData,
+    sendTransaction: wagmiSendTransaction
+  });
+}
+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;
+  } 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.'
+    );
+    wrappedError.cause = error;
+    throw wrappedError;
+  }
+}
+async function loadSiwe() {
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      "siwe"
+    );
+  } catch (error) {
+    const wrappedError = new Error(
+      'Wagmi walletAuth fallback requires the "siwe" package. Install siwe or provide a custom fallback.'
+    );
+    wrappedError.cause = error;
+    throw wrappedError;
+  }
+}
+async function checksumAddress(addr) {
+  try {
+    const { getAddress: getAddress2 } = await import(
+      /* webpackIgnore: true */
+      "viem"
+    );
+    return getAddress2(addr);
+  } catch {
+    return addr;
+  }
+}
 async function ensureConnected(config) {
-  const { connect, getConnections } = await import("wagmi/actions");
+  const { connect, getConnections } = await loadWagmiActions();
   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];
+    return checksumAddress(existingConnection.accounts[0]);
   }
   const connectors = config.connectors;
   if (!connectors || connectors.length === 0) {
@@ -74,7 +140,7 @@ async function ensureConnected(config) {
       const account = result.accounts[0];
       const address = typeof account === "string" ? account : account.address;
       if (address) {
-        return address;
+        return checksumAddress(address);
       }
     }
   } catch (error) {
@@ -88,14 +154,19 @@ 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: signMessage2 } = await import("wagmi/actions");
-  const { SiweMessage } = await import("siwe");
+  const { signMessage: signMessage2 } = await loadWagmiActions();
+  const { SiweMessage } = await loadSiwe();
   const address = await ensureConnected(config);
   if (!SIWE_NONCE_REGEX.test(params.nonce)) {
     throw new Error(
@@ -122,13 +193,17 @@ 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: signMessage2 } = await import("wagmi/actions");
+  const { signMessage: signMessage2 } = await loadWagmiActions();
   const address = await ensureConnected(config);
   const signature = await signMessage2(config, {
     account: address,
@@ -142,13 +217,18 @@ 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: signTypedData2, switchChain } = await import("wagmi/actions");
+  const { getChainId, signTypedData: signTypedData2, switchChain } = await loadWagmiActions();
   const address = await ensureConnected(config);
   if (params.chainId !== void 0) {
     const currentChainId = await getChainId(config);
@@ -175,13 +255,19 @@ function isChainMismatchError(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)
+  });
   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: sendTransaction2, switchChain } = await import("wagmi/actions");
+  const { getChainId, getWalletClient, sendTransaction: sendTransaction2, switchChain } = await loadWagmiActions();
   await ensureConnected(config);
   const targetChainId = params.chainId ?? config.chains?.[0]?.id;
   const ensureTargetChain = async () => {
@@ -224,9 +310,10 @@ async function wagmiSendTransaction(params) {
 
 // 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,
@@ -234,9 +321,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,
@@ -247,7 +336,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;
@@ -319,6 +409,8 @@ var CommandUnavailableError = class extends Error {
 var EventManager = class {
   constructor() {
     this.listeners = {
+      ["miniapp-attestation" /* MiniAppAttestation */]: () => {
+      },
       ["miniapp-payment" /* MiniAppPayment */]: () => {
       },
       ["miniapp-wallet-auth" /* MiniAppWalletAuth */]: () => {
@@ -383,7 +475,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" };
@@ -391,7 +483,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" };
   }
@@ -413,6 +505,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) {
@@ -474,6 +627,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) {
@@ -742,9 +927,6 @@ async function nativeSendHapticFeedback(options, ctx) {
   return payload;
 }
 
-// src/commands/send-transaction/index.ts
-var import_viem = require("viem");
-
 // src/commands/send-transaction/types.ts
 var SendTransactionError = class extends Error {
   constructor(code, details) {
@@ -759,16 +941,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;
@@ -781,6 +953,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);
@@ -797,6 +983,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]);
       }
     }
@@ -805,37 +992,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") {
@@ -861,15 +1059,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(
@@ -895,71 +1100,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;
@@ -1178,12 +1355,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") {
@@ -1243,16 +1421,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") {
@@ -1309,7 +1488,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 = "";
@@ -1399,14 +1578,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") {
@@ -1660,11 +1840,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',
    *   }],
    * });
    * ```
@@ -1789,6 +1968,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
   // ============================================================================
@@ -1967,6 +2166,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(
@@ -2054,13 +2255,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 _clearAddress() {
   if (typeof window === "undefined") return;
@@ -2184,16 +2390,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) {
@@ -2263,18 +2472,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}`);
           }
@@ -2352,7 +2564,8 @@ function createConnectorFn(name) {
             method: "eth_requestAccounts"
           });
           if (Array.isArray(accounts) && accounts.length > 0 && typeof accounts[0] === "string") {
-            return [accounts[0]];
+            _setAddress(accounts[0]);
+            return [_getAddress()];
           }
         } catch {
         }