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

package/build/command-exports.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,19 +15,13 @@ 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/command-exports.ts
 var command_exports_exports = {};
 __export(command_exports_exports, {
+  AttestationError: () => AttestationError,
+  AttestationErrorCodes: () => AttestationErrorCodes,
   COMMAND_VERSIONS: () => COMMAND_VERSIONS,
   ChatError: () => ChatError,
   ChatErrorCodes: () => ChatErrorCodes,
@@ -70,7 +62,9 @@ __export(command_exports_exports, {
   WalletAuthError: () => WalletAuthError,
   WalletAuthErrorCodes: () => WalletAuthErrorCodes,
   WalletAuthErrorMessage: () => WalletAuthErrorMessage,
+  attestation: () => attestation,
   chat: () => chat,
+  closeMiniApp: () => closeMiniApp,
   getContacts: () => getContacts,
   getPermissions: () => getPermissions,
   isCommandAvailable: () => isCommandAvailable,
@@ -93,6 +87,7 @@ module.exports = __toCommonJS(command_exports_exports);
 
 // src/commands/types.ts
 var Command = /* @__PURE__ */ ((Command2) => {
+  Command2["Attestation"] = "attestation";
   Command2["Pay"] = "pay";
   Command2["WalletAuth"] = "wallet-auth";
   Command2["SendTransaction"] = "send-transaction";
@@ -104,9 +99,11 @@ var Command = /* @__PURE__ */ ((Command2) => {
   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";
@@ -122,9 +119,10 @@ var ResponseEvent = /* @__PURE__ */ ((ResponseEvent2) => {
   return ResponseEvent2;
 })(ResponseEvent || {});
 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,
@@ -132,9 +130,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,
@@ -145,7 +145,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;
@@ -217,6 +218,8 @@ var CommandUnavailableError = class extends Error {
 var EventManager = class {
   constructor() {
     this.listeners = {
+      ["miniapp-attestation" /* MiniAppAttestation */]: () => {
+      },
       ["miniapp-payment" /* MiniAppPayment */]: () => {
       },
       ["miniapp-wallet-auth" /* MiniAppWalletAuth */]: () => {
@@ -260,191 +263,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 {
@@ -466,7 +284,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" };
@@ -474,7 +292,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" };
   }
@@ -496,6 +314,75 @@ function determineFallbackReason(command) {
   return "commandNotSupported";
 }
 
+// src/commands/attestation/types.ts
+var AttestationErrorCodes = /* @__PURE__ */ ((AttestationErrorCodes2) => {
+  AttestationErrorCodes2["Unauthorized"] = "unauthorized";
+  AttestationErrorCodes2["AttestationFailed"] = "attestation_failed";
+  AttestationErrorCodes2["IntegrityFailed"] = "integrity_failed";
+  AttestationErrorCodes2["InvalidInput"] = "invalid_input";
+  AttestationErrorCodes2["UnsupportedVersion"] = "unsupported_version";
+  return AttestationErrorCodes2;
+})(AttestationErrorCodes || {});
+var 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 ChatErrorCodes = /* @__PURE__ */ ((ChatErrorCodes2) => {
   ChatErrorCodes2["UserRejected"] = "user_rejected";
@@ -563,6 +450,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 GetPermissionsErrorCodes = /* @__PURE__ */ ((GetPermissionsErrorCodes2) => {
   GetPermissionsErrorCodes2["GenericError"] = "generic_error";
@@ -634,14 +553,27 @@ async function nativeGetPermissions(ctx) {
 var Tokens = /* @__PURE__ */ ((Tokens2) => {
   Tokens2["USDC"] = "USDCE";
   Tokens2["WLD"] = "WLD";
+  Tokens2["WARS"] = "WARS";
+  Tokens2["WCOP"] = "WCOP";
+  Tokens2["WMXN"] = "WMXN";
+  Tokens2["WBRL"] = "WBRL";
+  Tokens2["WPEN"] = "WPEN";
+  Tokens2["WCLP"] = "WCLP";
+  Tokens2["EURC"] = "EURC";
   return Tokens2;
 })(Tokens || {});
 var TokenDecimals = {
   ["USDCE" /* USDC */]: 6,
-  ["WLD" /* WLD */]: 18
+  ["WLD" /* WLD */]: 18,
+  ["WARS" /* WARS */]: 18,
+  ["WCOP" /* WCOP */]: 18,
+  ["WMXN" /* WMXN */]: 18,
+  ["WBRL" /* WBRL */]: 18,
+  ["WPEN" /* WPEN */]: 18,
+  ["WCLP" /* WCLP */]: 18,
+  ["EURC" /* EURC */]: 6
 };
 var Network = /* @__PURE__ */ ((Network2) => {
-  Network2["Optimism"] = "optimism";
   Network2["WorldChain"] = "worldchain";
   return Network2;
 })(Network || {});
@@ -902,8 +834,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 SendTransactionErrorCodes = /* @__PURE__ */ ((SendTransactionErrorCodes2) => {
@@ -960,16 +895,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;
@@ -982,6 +907,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);
@@ -998,6 +937,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]);
       }
     }
@@ -1006,37 +946,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") {
@@ -1062,15 +1013,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(
@@ -1096,71 +1054,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;
@@ -1401,12 +1331,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") {
@@ -1477,16 +1408,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") {
@@ -1543,7 +1475,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 = "";
@@ -1613,7 +1545,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" };
@@ -1621,7 +1553,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)"
@@ -1644,14 +1576,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") {
@@ -1764,6 +1697,8 @@ var MiniKitInstallErrorMessage = {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AttestationError,
+  AttestationErrorCodes,
   COMMAND_VERSIONS,
   ChatError,
   ChatErrorCodes,
@@ -1804,7 +1739,9 @@ var MiniKitInstallErrorMessage = {
   WalletAuthError,
   WalletAuthErrorCodes,
   WalletAuthErrorMessage,
+  attestation,
   chat,
+  closeMiniApp,
   getContacts,
   getPermissions,
   isCommandAvailable,