@worldcoin/minikit-js 2.0.2 → 2.0.3

package/build/connector/index.cjs

@@ -34,6 +34,179 @@ __export(connector_exports, {
 });
 module.exports = __toCommonJS(connector_exports);
 
+// src/global-keys.ts
+var WAGMI_CONFIG_KEY = "__minikit_wagmi_config__";
+var WAGMI_INSTALL_HOOK_KEY = "__minikit_install_wagmi_fallback__";
+
+// 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);
+}
+
+// src/commands/types.ts
+var COMMAND_VERSIONS = {
+  ["attestation" /* Attestation */]: 1,
+  ["pay" /* Pay */]: 1,
+  ["wallet-auth" /* WalletAuth */]: 2,
+  ["send-transaction" /* SendTransaction */]: 2,
+  ["sign-message" /* SignMessage */]: 1,
+  ["sign-typed-data" /* SignTypedData */]: 1,
+  ["share-contacts" /* ShareContacts */]: 1,
+  ["request-permission" /* RequestPermission */]: 1,
+  ["get-permissions" /* GetPermissions */]: 1,
+  ["send-haptic-feedback" /* SendHapticFeedback */]: 1,
+  ["share" /* Share */]: 1,
+  ["chat" /* Chat */]: 1,
+  ["close-miniapp" /* CloseMiniApp */]: 1
+};
+var commandAvailability = {
+  ["attestation" /* Attestation */]: false,
+  ["pay" /* Pay */]: false,
+  ["wallet-auth" /* WalletAuth */]: false,
+  ["send-transaction" /* SendTransaction */]: false,
+  ["sign-message" /* SignMessage */]: false,
+  ["sign-typed-data" /* SignTypedData */]: false,
+  ["share-contacts" /* ShareContacts */]: false,
+  ["request-permission" /* RequestPermission */]: false,
+  ["get-permissions" /* GetPermissions */]: false,
+  ["send-haptic-feedback" /* SendHapticFeedback */]: false,
+  ["share" /* Share */]: false,
+  ["chat" /* Chat */]: false,
+  ["close-miniapp" /* CloseMiniApp */]: false
+};
+function isCommandAvailable(command) {
+  return commandAvailability[command] ?? false;
+}
+function setCommandAvailable(command, available) {
+  commandAvailability[command] = available;
+}
+function validateCommands(worldAppSupportedCommands) {
+  let allCommandsValid = true;
+  Object.entries(COMMAND_VERSIONS).forEach(([commandName, version]) => {
+    const commandInput = worldAppSupportedCommands.find(
+      (cmd) => cmd.name === commandName
+    );
+    let isCommandValid = false;
+    if (!commandInput) {
+      console.warn(
+        `Command ${commandName} is not supported by the app. Try updating the app version`
+      );
+    } else {
+      if (commandInput.supported_versions.includes(version)) {
+        setCommandAvailable(commandName, true);
+        isCommandValid = true;
+      } else {
+        isCommandValid = true;
+        console.warn(
+          `Command ${commandName} version ${version} is not supported by the app. Supported versions: ${commandInput.supported_versions.join(", ")}. This is not an error, but it is recommended to update the World App version.`
+        );
+        setCommandAvailable(commandName, true);
+      }
+    }
+    if (!isCommandValid) {
+      allCommandsValid = false;
+    }
+  });
+  return allCommandsValid;
+}
+function sendMiniKitEvent(payload) {
+  if (window.webkit) {
+    window.webkit?.messageHandlers?.minikit?.postMessage?.(payload);
+  } else if (window.Android) {
+    window.Android?.postMessage?.(JSON.stringify(payload));
+  }
+}
+function isInWorldApp() {
+  return typeof window !== "undefined" && Boolean(window.WorldApp);
+}
+var FallbackRequiredError = class extends Error {
+  constructor(command) {
+    super(
+      `${command} requires a fallback function when running outside World App. Provide a fallback option: MiniKit.${command}({ ..., fallback: () => yourFallback() })`
+    );
+    this.name = "FallbackRequiredError";
+  }
+};
+var CommandUnavailableError = class extends Error {
+  constructor(command, reason) {
+    const messages = {
+      notInWorldApp: "Not running inside World App",
+      commandNotSupported: "Command not supported in this environment",
+      oldAppVersion: "World App version does not support this command"
+    };
+    super(`${command} is unavailable: ${messages[reason]}`);
+    this.name = "CommandUnavailableError";
+    this.reason = reason;
+  }
+};
+
+// src/commands/fallback.ts
+var PartialExecutionError = class extends Error {
+  constructor(message, submitted, cause) {
+    super(message);
+    this.name = "PartialExecutionError";
+    this.submitted = submitted;
+    this.cause = cause;
+  }
+};
+async function executeWithFallback(options) {
+  const {
+    command,
+    nativeExecutor,
+    wagmiFallback,
+    customFallback,
+    requiresFallback = false
+  } = options;
+  const inWorldApp = isInWorldApp();
+  const commandAvailable = isCommandAvailable(command);
+  let nativeError;
+  if (inWorldApp && commandAvailable) {
+    try {
+      const data = await nativeExecutor();
+      return { data, executedWith: "minikit" };
+    } catch (error) {
+      nativeError = error;
+      console.warn(`Native ${command} failed, attempting fallback:`, error);
+    }
+  }
+  if (!inWorldApp && wagmiFallback) {
+    try {
+      const data = await wagmiFallback();
+      return { data, executedWith: "wagmi" };
+    } catch (error) {
+      if (error instanceof PartialExecutionError || error instanceof Error && error.name === "PartialExecutionError") {
+        throw error;
+      }
+      console.warn(`Wagmi fallback for ${command} failed:`, error);
+    }
+  }
+  if (!inWorldApp && customFallback) {
+    const data = await customFallback();
+    return { data, executedWith: "fallback" };
+  }
+  if (nativeError) {
+    throw nativeError;
+  }
+  if (requiresFallback && !inWorldApp) {
+    throw new FallbackRequiredError(command);
+  }
+  throw new CommandUnavailableError(command, determineFallbackReason(command));
+}
+function determineFallbackReason(command) {
+  if (!isInWorldApp()) {
+    return "notInWorldApp";
+  }
+  if (!isCommandAvailable(command)) {
+    return "oldAppVersion";
+  }
+  return "commandNotSupported";
+}
+
 // src/commands/fallback-adapter-registry.ts
 var FALLBACK_ADAPTER_KEY = "__minikit_fallback_adapter__";
 function setFallbackAdapter(adapter) {
@@ -45,16 +218,13 @@ function getFallbackAdapter() {
 
 // 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({
@@ -65,21 +235,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.'
     );
@@ -89,10 +247,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.'
@@ -103,10 +258,7 @@ async function loadSiwe() {
 }
 async function checksumAddress(addr) {
   try {
-    const { getAddress: getAddress2 } = await import(
-      /* webpackIgnore: true */
-      "viem"
-    );
+    const { getAddress: getAddress2 } = await import("viem");
     return getAddress2(addr);
   } catch {
     return addr;
@@ -119,7 +271,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) {
@@ -140,7 +295,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) {
@@ -154,20 +312,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: signMessage2 } = 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)"
@@ -185,7 +338,11 @@ async function wagmiWalletAuth(params) {
     expirationTime: params.expirationTime?.toISOString()
   });
   const message = siweMessage.prepareMessage();
-  const signature = await signMessage2(config, { message });
+  const signature = await signMessage2(config, {
+    connector,
+    account: address,
+    message
+  });
   return {
     address,
     message,
@@ -193,19 +350,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: signMessage2 } = await loadWagmiActions();
-  const address = await ensureConnected(config);
+  const { address, connector } = await ensureConnected(config);
   const signature = await signMessage2(config, {
+    connector,
     account: address,
     message: params.message
   });
@@ -217,26 +371,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: signTypedData2, 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 signTypedData2(config, {
+    connector,
     account: address,
     types: params.types,
     primaryType: params.primaryType,
@@ -254,27 +404,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: sendTransaction2, 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);
@@ -285,125 +467,42 @@ async function wagmiSendTransaction(params) {
     }
   };
   await ensureTargetChain();
-  let transactionHash;
-  try {
-    transactionHash = await sendTransaction2(config, {
+  const sendWithChainRetry = async (tx) => {
+    const send = () => sendTransaction2(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;
     }
-    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/types.ts
-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.`
+  };
+  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
         );
-        setCommandAvailable(commandName, true);
       }
+      throw error;
     }
-    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));
   }
+  return { transactionHash: submitted[submitted.length - 1] };
 }
-function isInWorldApp() {
-  return typeof window !== "undefined" && Boolean(window.WorldApp);
-}
-var FallbackRequiredError = class extends Error {
-  constructor(command) {
-    super(
-      `${command} requires a fallback function when running outside World App. Provide a fallback option: MiniKit.${command}({ ..., fallback: () => yourFallback() })`
-    );
-    this.name = "FallbackRequiredError";
-  }
-};
-var CommandUnavailableError = class extends Error {
-  constructor(command, reason) {
-    const messages = {
-      notInWorldApp: "Not running inside World App",
-      commandNotSupported: "Command not supported in this environment",
-      oldAppVersion: "World App version does not support this command"
-    };
-    super(`${command} is unavailable: ${messages[reason]}`);
-    this.name = "CommandUnavailableError";
-    this.reason = reason;
-  }
-};
 
 // src/events.ts
 var EventManager = class {
@@ -454,57 +553,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/types.ts
 var AttestationError = class extends Error {
   constructor(error_code) {
@@ -997,7 +1045,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;
 }
@@ -1024,12 +1071,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),
@@ -1110,23 +1151,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 {
@@ -2294,12 +2328,6 @@ function _clearAddress() {
 function rpcError(code, message) {
   return Object.assign(new Error(message), { code });
 }
-function isHexString(value) {
-  return /^0x[0-9a-fA-F]*$/.test(value);
-}
-function isAddressString(value) {
-  return /^0x[0-9a-fA-F]{40}$/.test(value);
-}
 function decodeHexToUtf8(hex) {
   const raw = hex.slice(2);
   if (raw.length % 2 !== 0) {
@@ -2331,7 +2359,7 @@ function extractPersonalSignMessage(params) {
     throw new Error("Missing personal_sign params");
   }
   const [first, second] = items;
-  const maybeMessage = typeof first === "string" && isAddressString(first) && typeof second === "string" ? second : first;
+  const maybeMessage = typeof first === "string" && isHexAddress(first) && typeof second === "string" ? second : first;
   if (typeof maybeMessage !== "string") {
     throw new Error("Invalid personal_sign message payload");
   }
@@ -2343,7 +2371,7 @@ function extractEthSignMessage(params) {
     throw new Error("Missing eth_sign params");
   }
   const [first, second] = items;
-  const maybeMessage = typeof second === "string" ? second : typeof first === "string" && !isAddressString(first) ? first : void 0;
+  const maybeMessage = typeof second === "string" ? second : typeof first === "string" && !isHexAddress(first) ? first : void 0;
   if (typeof maybeMessage !== "string") {
     throw new Error("Invalid eth_sign message payload");
   }
@@ -2380,7 +2408,7 @@ function normalizeRpcValue(value) {
 function extractTransactionParams(params) {
   const items = asArrayParams(params);
   const tx = items[0] ?? {};
-  if (typeof tx.to !== "string" || !isAddressString(tx.to)) {
+  if (typeof tx.to !== "string" || !isHexAddress(tx.to)) {
     throw new Error('Invalid transaction "to" address');
   }
   const chainId = typeof tx.chainId === "string" ? Number(tx.chainId) : typeof tx.chainId === "number" ? tx.chainId : void 0;