@d13co/use-wallet 4.5.4 → 4.5.6

package/dist/index.cjs

@@ -5479,12 +5479,11 @@ __export(index_exports, {
   LogLevel: () => LogLevel,
   LuteWallet: () => LuteWallet,
   MagicAuth: () => MagicAuth,
-  MetaMaskWallet: () => MetaMaskWallet,
   MnemonicWallet: () => MnemonicWallet,
   NetworkConfigBuilder: () => NetworkConfigBuilder,
   NetworkId: () => NetworkId,
   PeraWallet: () => PeraWallet,
-  RainbowWallet: () => RainbowWallet,
+  RainbowKitWallet: () => RainbowKitWallet,
   ScopeType: () => ScopeType,
   SecureKeyContainer: () => SecureKeyContainer,
   SessionError: () => SessionError,
@@ -5577,7 +5576,7 @@ var Logger = class _Logger {
 var logger = Logger.getInstance();
 
 // src/manager.ts
-var import_store16 = require("@tanstack/store");
+var import_store15 = require("@tanstack/store");
 var import_algosdk15 = __toESM(require("algosdk"), 1);
 
 // src/network.ts
@@ -5782,10 +5781,9 @@ var WalletId = /* @__PURE__ */ ((WalletId2) => {
   WalletId2["KMD"] = "kmd";
   WalletId2["LUTE"] = "lute";
   WalletId2["MAGIC"] = "magic";
-  WalletId2["METAMASK"] = "metamask";
   WalletId2["MNEMONIC"] = "mnemonic";
   WalletId2["PERA"] = "pera";
-  WalletId2["RAINBOW"] = "rainbow";
+  WalletId2["RAINBOWKIT"] = "rainbowkit";
   WalletId2["WALLETCONNECT"] = "walletconnect";
   WalletId2["WEB3AUTH"] = "web3auth";
   WalletId2["W3_WALLET"] = "w3-wallet";
@@ -6027,6 +6025,14 @@ var BaseWallet = class {
     return networkConfig[activeNetwork];
   }
   // ---------- Protected Methods ------------------------------------- //
+  /**
+   * Dynamically update wallet metadata (e.g., after learning the actual
+   * connector name/icon during connect).
+   */
+  updateMetadata(updates) {
+    ;
+    this.metadata = { ...this.metadata, ...updates };
+  }
   onDisconnect = () => {
     this.logger.debug(`Removing wallet from store...`);
     removeWallet(this.store, { walletId: this.walletKey });
@@ -8240,109 +8246,142 @@ var MagicAuth = class extends BaseWallet {
   };
 };
 
-// src/wallets/liquid-evm-base.ts
+// src/wallets/mnemonic.ts
 var import_algosdk9 = __toESM(require("algosdk"), 1);
-var LiquidEvmBaseWallet = class extends BaseWallet {
-  liquidEvmSdk = null;
-  algorandClient = null;
-  evmAddressMap = /* @__PURE__ */ new Map();
-  // algorandAddress -> evmAddress
+var LOCAL_STORAGE_MNEMONIC_KEY = `${LOCAL_STORAGE_KEY}_mnemonic`;
+var ICON11 = `data:image/svg+xml;base64,${btoa(`
+<svg viewBox="0 0 400 400" xmlns="http://www.w3.org/2000/svg">
+  <rect fill="#525252" width="400" height="400" />
+  <path fill="#FFFFFF" d="M309.2,309.3H275l-22.2-82.7l-47.9,82.7h-38.3l73.9-128l-11.9-44.5l-99.6,172.6H90.8L217.1,90.6 h33.5l14.7,54.3h34.6l-23.6,41L309.2,309.3z" />
+</svg>
+`)}`;
+var MnemonicWallet = class extends BaseWallet {
+  account = null;
   options;
   store;
-  constructor(params) {
-    super(params);
-    this.options = params.options || {};
-    this.store = params.store;
-  }
-  /**
-   * Default metadata for Liquid EVM wallets.
-   * Subclasses MUST override this with their own metadata including isLiquid: "EVM"
-   */
-  static defaultMetadata;
-  /**
-   * Ensure the wallet is on the Algorand chain (4160).
-   * Queries the current chain first, and only switches/adds if needed.
-   */
-  async ensureAlgorandChain() {
-    const provider = await this.getEvmProvider();
-    const { ALGORAND_CHAIN_ID_HEX, ALGORAND_EVM_CHAIN_CONFIG } = await import("liquid-accounts-evm");
-    const currentChainId = await provider.request({ method: "eth_chainId" });
-    if (currentChainId === ALGORAND_CHAIN_ID_HEX) {
-      return;
+  constructor({
+    id,
+    store,
+    subscribe,
+    getAlgodClient,
+    options,
+    metadata = {}
+  }) {
+    super({ id, metadata, getAlgodClient, store, subscribe });
+    const {
+      persistToStorage = false,
+      promptForMnemonic = () => Promise.resolve(prompt("Enter 25-word mnemonic passphrase:"))
+    } = options || {};
+    this.options = { persistToStorage, promptForMnemonic };
+    this.store = store;
+    if (this.options.persistToStorage) {
+      this.logger.warn(
+        "Persisting mnemonics to storage is insecure. Any private key mnemonics used should never hold real Algos (i.e., on MainNet). Use with caution!"
+      );
     }
-    this.logger.info(
-      `Wrong chain (${currentChainId}), switching to Algorand (${ALGORAND_CHAIN_ID_HEX})...`
-    );
+  }
+  static defaultMetadata = {
+    name: "Mnemonic",
+    icon: ICON11
+  };
+  loadMnemonicFromStorage() {
+    return StorageAdapter.getItem(LOCAL_STORAGE_MNEMONIC_KEY);
+  }
+  saveMnemonicToStorage(mnemonic) {
+    StorageAdapter.setItem(LOCAL_STORAGE_MNEMONIC_KEY, mnemonic);
+  }
+  removeMnemonicFromStorage() {
+    StorageAdapter.removeItem(LOCAL_STORAGE_MNEMONIC_KEY);
+  }
+  checkMainnet() {
     try {
-      await provider.request({
-        method: "wallet_switchEthereumChain",
-        params: [{ chainId: ALGORAND_CHAIN_ID_HEX }]
-      });
-    } catch (switchError) {
-      if (switchError.code === 4902) {
-        this.logger.info("Algorand chain not found, adding it...");
-        await provider.request({
-          method: "wallet_addEthereumChain",
-          params: [ALGORAND_EVM_CHAIN_CONFIG]
-        });
-      } else {
-        throw switchError;
+      const network = this.activeNetworkConfig;
+      if (!network.isTestnet) {
+        this.logger.warn(
+          "The Mnemonic wallet provider is insecure and intended for testing only. Any private key mnemonics used should never hold real Algos (i.e., on MainNet)."
+        );
+        throw new Error("Production network detected. Aborting.");
       }
+    } catch (error) {
+      this.disconnect();
+      throw error;
     }
   }
-  /**
-   * Initialize the Liquid EVM SDK for deriving Algorand addresses
-   */
-  async initializeEvmSdk() {
-    if (!this.liquidEvmSdk) {
-      this.logger.info("Initializing Liquid EVM SDK...");
-      if (!this.algorandClient) {
-        const { AlgorandClient } = await import("@algorandfoundation/algokit-utils");
-        const algodClient = this.getAlgodClient();
-        this.algorandClient = AlgorandClient.fromClients({
-          algod: algodClient
-        });
+  async initializeAccount() {
+    let mnemonic = this.loadMnemonicFromStorage();
+    if (!mnemonic) {
+      mnemonic = await this.options.promptForMnemonic();
+      if (!mnemonic) {
+        this.account = null;
+        this.logger.error("No mnemonic provided");
+        throw new Error("No mnemonic provided");
+      }
+      if (this.options.persistToStorage) {
+        this.logger.warn("Mnemonic saved to localStorage.");
+        this.saveMnemonicToStorage(mnemonic);
       }
-      const { LiquidEvmSdk } = await import("liquid-accounts-evm");
-      this.liquidEvmSdk = new LiquidEvmSdk({ algorand: this.algorandClient });
-      this.logger.info("Liquid EVM SDK initialized");
     }
-    return this.liquidEvmSdk;
+    const account = import_algosdk9.default.mnemonicToSecretKey(mnemonic);
+    this.account = account;
+    return account;
   }
-  /**
-   * Derive Algorand accounts from EVM addresses
-   */
-  async deriveAlgorandAccounts(evmAddresses) {
-    const liquidEvmSdk = await this.initializeEvmSdk();
-    const walletAccounts = [];
-    for (let i = 0; i < evmAddresses.length; i++) {
-      const evmAddress = evmAddresses[i];
-      const algorandAddress = await liquidEvmSdk.getAddress({ evmAddress });
-      this.evmAddressMap.set(algorandAddress, evmAddress);
-      walletAccounts.push({
-        name: `${this.metadata.name} ${evmAddress}`,
-        address: algorandAddress,
-        metadata: { evmAddress }
-      });
+  connect = async () => {
+    this.checkMainnet();
+    this.logger.info("Connecting...");
+    const account = await this.initializeAccount();
+    const walletAccount = {
+      name: `${this.metadata.name} Account`,
+      address: account.addr.toString()
+    };
+    const walletState = {
+      accounts: [walletAccount],
+      activeAccount: walletAccount
+    };
+    addWallet(this.store, {
+      walletId: this.id,
+      wallet: walletState
+    });
+    this.logger.info("Connected successfully", walletState);
+    return [walletAccount];
+  };
+  disconnect = async () => {
+    this.logger.info("Disconnecting...");
+    this.onDisconnect();
+    this.account = null;
+    this.removeMnemonicFromStorage();
+    this.logger.info("Disconnected");
+  };
+  resumeSession = async () => {
+    this.checkMainnet();
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    if (!walletState) {
+      this.logger.info("No session to resume");
+      return;
     }
-    return walletAccounts;
-  }
-  /**
-   * Convert bytes to hex string with 0x prefix
-   */
-  bytesToHex(bytes) {
-    return "0x" + Array.from(bytes).map((b3) => b3.toString(16).padStart(2, "0")).join("");
-  }
+    this.logger.info("Resuming session...");
+    if (this.options.persistToStorage) {
+      try {
+        await this.initializeAccount();
+        this.logger.info("Session resumed successfully");
+      } catch (error) {
+        this.logger.error("Error resuming session:", error.message);
+        this.disconnect();
+        throw error;
+      }
+    } else {
+      this.logger.info("No session to resume, disconnecting...");
+      this.disconnect();
+    }
+  };
   processTxns(txnGroup, indexesToSign) {
     const txnsToSign = [];
     txnGroup.forEach((txn, index) => {
       const isIndexMatch = !indexesToSign || indexesToSign.includes(index);
       const signer = txn.sender.toString();
-      const canSignTxn = this.addresses.includes(signer);
+      const canSignTxn = signer === this.account.addr.toString();
       if (isIndexMatch && canSignTxn) {
-        txnsToSign.push({ txn });
-      } else {
-        txnsToSign.push({ txn, signers: [] });
+        txnsToSign.push(txn);
       }
     });
     return txnsToSign;
@@ -8355,22 +8394,17 @@ var LiquidEvmBaseWallet = class extends BaseWallet {
       const txn = isSigned ? import_algosdk9.default.decodeSignedTransaction(txnBuffer).txn : import_algosdk9.default.decodeUnsignedTransaction(txnBuffer);
       const isIndexMatch = !indexesToSign || indexesToSign.includes(index);
       const signer = txn.sender.toString();
-      const canSignTxn = !isSigned && this.addresses.includes(signer);
+      const canSignTxn = !isSigned && signer === this.account.addr.toString();
       if (isIndexMatch && canSignTxn) {
-        txnsToSign.push({ txn });
-      } else {
-        txnsToSign.push({ txn, signers: [] });
+        txnsToSign.push(txn);
       }
     });
     return txnsToSign;
   }
-  /**
-   * Sign Algorand transactions using EVM wallet signatures
-   */
   signTransactions = async (txnGroup, indexesToSign) => {
+    this.checkMainnet();
     try {
       this.logger.debug("Signing transactions...", { txnGroup, indexesToSign });
-      const liquidEvmSdk = await this.initializeEvmSdk();
       let txnsToSign = [];
       if (isTransactionArray(txnGroup)) {
         const flatTxns = flattenTxnGroup(txnGroup);
@@ -8379,412 +8413,19 @@ var LiquidEvmBaseWallet = class extends BaseWallet {
         const flatTxns = flattenTxnGroup(txnGroup);
         txnsToSign = this.processEncodedTxns(flatTxns, indexesToSign);
       }
-      const firstTxn = txnsToSign[0];
-      const algorandAddress = firstTxn.txn.sender.toString();
-      const evmAddress = this.evmAddressMap.get(algorandAddress);
-      if (!evmAddress) {
-        throw new Error(`No EVM address found for Algorand address: ${algorandAddress}`);
-      }
-      const onBeforeSign = this.options.uiHooks?.onBeforeSign ?? this.managerUIHooks?.onBeforeSign;
-      if (onBeforeSign) {
-        this.logger.debug("Running onBeforeSign hook", { txnGroup, indexesToSign });
-        const txnsAsUint8 = txnsToSign.map(({ txn }) => import_algosdk9.default.encodeUnsignedTransaction(txn));
-        await onBeforeSign(txnsAsUint8, indexesToSign);
-      }
-      await this.ensureAlgorandChain();
-      const { signer: evmSigner } = await liquidEvmSdk.getSigner({
-        evmAddress,
-        signMessage: (typedData) => this.signWithProvider(typedData, evmAddress)
-      });
-      const allTxns = txnsToSign.map((t) => t.txn);
-      const signIndexes = txnsToSign.reduce((acc, t, i) => {
-        if (!("signers" in t)) acc.push(i);
-        return acc;
-      }, []);
-      const signedBlobs = await evmSigner(allTxns, signIndexes);
-      const onAfterSign = this.options.uiHooks?.onAfterSign ?? this.managerUIHooks?.onAfterSign;
-      if (onAfterSign) {
-        this.logger.debug("Running onAfterSign hook");
-        try {
-          onAfterSign(true);
-        } catch (e) {
-        }
-      }
-      let signedIdx = 0;
-      const result = txnsToSign.map((_2, index) => {
-        if (signIndexes.includes(index)) {
-          return signedBlobs[signedIdx++];
-        }
-        return null;
-      });
-      this.logger.debug("Transactions signed successfully", result);
-      return result;
+      const signedTxns = txnsToSign.map((txn) => txn.signTxn(this.account.sk));
+      this.logger.debug("Transactions signed successfully", { signedTxns });
+      return signedTxns;
     } catch (error) {
-      try {
-        const onAfterSignCleanup = this.options.uiHooks?.onAfterSign ?? this.managerUIHooks?.onAfterSign;
-        onAfterSignCleanup?.(false, error.message);
-      } catch (e) {
-      }
       this.logger.error("Error signing transactions:", error.message);
       throw error;
     }
   };
-  /**
-   * Helper to compare and update accounts if needed during session resume
-   */
-  async resumeWithAccounts(evmAddresses, setAccountsFn) {
-    const state = this.store.state;
-    const walletState = state.wallets[this.id];
-    if (!walletState) {
-      this.logger.info("No session to resume");
-      return;
-    }
-    for (const account of walletState.accounts) {
-      const evmAddr = account.metadata?.evmAddress;
-      if (evmAddr) {
-        this.evmAddressMap.set(account.address, evmAddr);
-      }
-    }
-    const walletAccounts = await this.deriveAlgorandAccounts(evmAddresses);
-    const match = compareAccounts(walletAccounts, walletState.accounts);
-    if (!match) {
-      this.logger.warn("Session accounts mismatch, updating accounts", {
-        prev: walletState.accounts,
-        current: walletAccounts
-      });
-      setAccountsFn(walletAccounts);
-    }
-    this.logger.info("Session resumed");
-  }
-  notifyConnect(evmAddress, algorandAddress) {
-    const onConnect = this.options.uiHooks?.onConnect ?? this.managerUIHooks?.onConnect;
-    if (onConnect) {
-      onConnect({ evmAddress, algorandAddress });
-    }
-  }
 };
 
-// src/wallets/metamask.ts
-var ICON11 = `data:image/svg+xml;base64,${btoa(`
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 142 136.878" style="enable-background:new 0 0 142 136.878;" xml:space="preserve">
-<path style="fill:#FF5C16;" d="M132.682,132.192l-30.583-9.106l-23.063,13.787l-16.092-0.007l-23.077-13.78l-30.569,9.106L0,100.801
-	l9.299-34.839L0,36.507L9.299,0l47.766,28.538h27.85L132.682,0l9.299,36.507l-9.299,29.455l9.299,34.839L132.682,132.192
-	L132.682,132.192z"/>
-<path style="fill:#FF5C16;" d="M9.305,0l47.767,28.558l-1.899,19.599L9.305,0z M39.875,100.814l21.017,16.01l-21.017,6.261
-	C39.875,123.085,39.875,100.814,39.875,100.814z M59.212,74.345l-4.039-26.174L29.317,65.97l-0.014-0.007v0.013l0.08,18.321
-	l10.485-9.951L59.212,74.345L59.212,74.345z M132.682,0L84.915,28.558l1.893,19.599L132.682,0z M102.113,100.814l-21.018,16.01
-	l21.018,6.261V100.814z M112.678,65.975h0.007H112.678v-0.013l-0.006,0.007L86.815,48.171l-4.039,26.174h19.336l10.492,9.95
-	C112.604,84.295,112.678,65.975,112.678,65.975z"/>
-<path style="fill:#E34807;" d="M39.868,123.085l-30.569,9.106L0,100.814h39.868C39.868,100.814,39.868,123.085,39.868,123.085z
-	 M59.205,74.338l5.839,37.84l-8.093-21.04L29.37,84.295l10.491-9.956h19.344L59.205,74.338z M102.112,123.085l30.57,9.106
-	l9.299-31.378h-39.869C102.112,100.814,102.112,123.085,102.112,123.085z M82.776,74.338l-5.839,37.84l8.092-21.04l27.583-6.843
-	l-10.498-9.956H82.776V74.338z"/>
-<path style="fill:#FF8D5D;" d="M0,100.801l9.299-34.839h19.997l0.073,18.327l27.584,6.843l8.092,21.039l-4.16,4.633l-21.017-16.01H0
-	V100.801z M141.981,100.801l-9.299-34.839h-19.998l-0.073,18.327l-27.582,6.843l-8.093,21.039l4.159,4.633l21.018-16.01h39.868
-	V100.801z M84.915,28.538h-27.85l-1.891,19.599l9.872,64.013h11.891l9.878-64.013L84.915,28.538z"/>
-<path style="fill:#661800;" d="M9.299,0L0,36.507l9.299,29.455h19.997l25.87-17.804L9.299,0z M53.426,81.938h-9.059l-4.932,4.835
-	l17.524,4.344l-3.533-9.186V81.938z M132.682,0l9.299,36.507l-9.299,29.455h-19.998L86.815,48.158L132.682,0z M88.568,81.938h9.072
-	l4.932,4.841l-17.544,4.353l3.54-9.201V81.938z M79.029,124.385l2.067-7.567l-4.16-4.633h-11.9l-4.159,4.633l2.066,7.567"/>
-<path style="fill:#C0C4CD;" d="M79.029,124.384v12.495H62.945v-12.495L79.029,124.384L79.029,124.384z"/>
-<path style="fill:#E7EBF6;" d="M39.875,123.072l23.083,13.8v-12.495l-2.067-7.566C60.891,116.811,39.875,123.072,39.875,123.072z
-	 M102.113,123.072l-23.084,13.8v-12.495l2.067-7.566C81.096,116.811,102.113,123.072,102.113,123.072z"/>
-</svg>
-`)}`;
-var MetaMaskWallet = class extends LiquidEvmBaseWallet {
-  metamaskSdk = null;
-  provider = null;
-  options;
-  constructor(params) {
-    super(params);
-    this.options = params.options || {};
-  }
-  static defaultMetadata = {
-    name: "MetaMask",
-    icon: ICON11,
-    isLiquid: "EVM"
-  };
-  async initializeProvider() {
-    if (!this.metamaskSdk) {
-      this.logger.info("Initializing MetaMask SDK...");
-      const { MetaMaskSDK } = await import("@metamask/sdk");
-      this.metamaskSdk = new MetaMaskSDK({
-        dappMetadata: {
-          name: this.options.dappMetadata?.name || "Algorand dApp",
-          url: this.options.dappMetadata?.url || (typeof window !== "undefined" ? window.location.href : ""),
-          ...this.options.dappMetadata?.iconUrl && { iconUrl: this.options.dappMetadata.iconUrl }
-        }
-      });
-      this.logger.info("MetaMask SDK initialized");
-    }
-  }
-  async getEvmProvider() {
-    if (!this.provider) {
-      await this.initializeProvider();
-      this.provider = this.metamaskSdk.getProvider() || null;
-      if (!this.provider) {
-        throw new Error("MetaMask provider not available. Please install MetaMask.");
-      }
-    }
-    return this.provider;
-  }
-  async signWithProvider(typedData, evmAddress) {
-    const provider = await this.getEvmProvider();
-    return await provider.request({
-      method: "eth_signTypedData_v4",
-      params: [evmAddress, JSON.stringify(typedData)]
-    });
-  }
-  connect = async () => {
-    this.logger.info("Connecting...");
-    await this.initializeProvider();
-    await this.initializeEvmSdk();
-    const provider = await this.getEvmProvider();
-    const evmAddresses = await provider.request({
-      method: "eth_requestAccounts"
-    });
-    if (evmAddresses.length === 0) {
-      this.logger.error("No accounts found!");
-      throw new Error("No accounts found!");
-    }
-    this.logger.info(`Connected to ${evmAddresses.length} EVM account(s)`);
-    const walletAccounts = await this.deriveAlgorandAccounts(evmAddresses);
-    const activeAccount = walletAccounts[0];
-    const walletState = {
-      accounts: walletAccounts,
-      activeAccount
-    };
-    addWallet(this.store, {
-      walletId: this.id,
-      wallet: walletState
-    });
-    this.logger.info("\u2705 Connected.", walletState);
-    this.notifyConnect(evmAddresses[0], activeAccount.address);
-    return walletAccounts;
-  };
-  disconnect = async () => {
-    this.logger.info("Disconnecting...");
-    if (this.metamaskSdk) {
-      await this.metamaskSdk.terminate();
-    }
-    this.provider = null;
-    this.evmAddressMap.clear();
-    this.onDisconnect();
-    this.logger.info("Disconnected");
-  };
-  resumeSession = async () => {
-    try {
-      const state = this.store.state;
-      const walletState = state.wallets[this.id];
-      if (!walletState) {
-        this.logger.info("No session to resume");
-        return;
-      }
-      this.logger.info("Resuming session...");
-      await this.initializeProvider();
-      await this.initializeEvmSdk();
-      const provider = await this.getEvmProvider();
-      const evmAddresses = await provider.request({
-        method: "eth_accounts"
-      });
-      if (evmAddresses.length === 0) {
-        this.logger.error("No accounts found!");
-        throw new Error("No accounts found!");
-      }
-      await this.resumeWithAccounts(evmAddresses, (accounts) => {
-        setAccounts(this.store, {
-          walletId: this.id,
-          accounts
-        });
-      });
-    } catch (error) {
-      this.logger.error("Error resuming session:", error.message);
-      this.onDisconnect();
-      throw error;
-    }
-  };
-};
-
-// src/wallets/mnemonic.ts
+// src/wallets/pera.ts
 var import_algosdk10 = __toESM(require("algosdk"), 1);
-var LOCAL_STORAGE_MNEMONIC_KEY = `${LOCAL_STORAGE_KEY}_mnemonic`;
 var ICON12 = `data:image/svg+xml;base64,${btoa(`
-<svg viewBox="0 0 400 400" xmlns="http://www.w3.org/2000/svg">
-  <rect fill="#525252" width="400" height="400" />
-  <path fill="#FFFFFF" d="M309.2,309.3H275l-22.2-82.7l-47.9,82.7h-38.3l73.9-128l-11.9-44.5l-99.6,172.6H90.8L217.1,90.6 h33.5l14.7,54.3h34.6l-23.6,41L309.2,309.3z" />
-</svg>
-`)}`;
-var MnemonicWallet = class extends BaseWallet {
-  account = null;
-  options;
-  store;
-  constructor({
-    id,
-    store,
-    subscribe,
-    getAlgodClient,
-    options,
-    metadata = {}
-  }) {
-    super({ id, metadata, getAlgodClient, store, subscribe });
-    const {
-      persistToStorage = false,
-      promptForMnemonic = () => Promise.resolve(prompt("Enter 25-word mnemonic passphrase:"))
-    } = options || {};
-    this.options = { persistToStorage, promptForMnemonic };
-    this.store = store;
-    if (this.options.persistToStorage) {
-      this.logger.warn(
-        "Persisting mnemonics to storage is insecure. Any private key mnemonics used should never hold real Algos (i.e., on MainNet). Use with caution!"
-      );
-    }
-  }
-  static defaultMetadata = {
-    name: "Mnemonic",
-    icon: ICON12
-  };
-  loadMnemonicFromStorage() {
-    return StorageAdapter.getItem(LOCAL_STORAGE_MNEMONIC_KEY);
-  }
-  saveMnemonicToStorage(mnemonic) {
-    StorageAdapter.setItem(LOCAL_STORAGE_MNEMONIC_KEY, mnemonic);
-  }
-  removeMnemonicFromStorage() {
-    StorageAdapter.removeItem(LOCAL_STORAGE_MNEMONIC_KEY);
-  }
-  checkMainnet() {
-    try {
-      const network = this.activeNetworkConfig;
-      if (!network.isTestnet) {
-        this.logger.warn(
-          "The Mnemonic wallet provider is insecure and intended for testing only. Any private key mnemonics used should never hold real Algos (i.e., on MainNet)."
-        );
-        throw new Error("Production network detected. Aborting.");
-      }
-    } catch (error) {
-      this.disconnect();
-      throw error;
-    }
-  }
-  async initializeAccount() {
-    let mnemonic = this.loadMnemonicFromStorage();
-    if (!mnemonic) {
-      mnemonic = await this.options.promptForMnemonic();
-      if (!mnemonic) {
-        this.account = null;
-        this.logger.error("No mnemonic provided");
-        throw new Error("No mnemonic provided");
-      }
-      if (this.options.persistToStorage) {
-        this.logger.warn("Mnemonic saved to localStorage.");
-        this.saveMnemonicToStorage(mnemonic);
-      }
-    }
-    const account = import_algosdk10.default.mnemonicToSecretKey(mnemonic);
-    this.account = account;
-    return account;
-  }
-  connect = async () => {
-    this.checkMainnet();
-    this.logger.info("Connecting...");
-    const account = await this.initializeAccount();
-    const walletAccount = {
-      name: `${this.metadata.name} Account`,
-      address: account.addr.toString()
-    };
-    const walletState = {
-      accounts: [walletAccount],
-      activeAccount: walletAccount
-    };
-    addWallet(this.store, {
-      walletId: this.id,
-      wallet: walletState
-    });
-    this.logger.info("Connected successfully", walletState);
-    return [walletAccount];
-  };
-  disconnect = async () => {
-    this.logger.info("Disconnecting...");
-    this.onDisconnect();
-    this.account = null;
-    this.removeMnemonicFromStorage();
-    this.logger.info("Disconnected");
-  };
-  resumeSession = async () => {
-    this.checkMainnet();
-    const state = this.store.state;
-    const walletState = state.wallets[this.id];
-    if (!walletState) {
-      this.logger.info("No session to resume");
-      return;
-    }
-    this.logger.info("Resuming session...");
-    if (this.options.persistToStorage) {
-      try {
-        await this.initializeAccount();
-        this.logger.info("Session resumed successfully");
-      } catch (error) {
-        this.logger.error("Error resuming session:", error.message);
-        this.disconnect();
-        throw error;
-      }
-    } else {
-      this.logger.info("No session to resume, disconnecting...");
-      this.disconnect();
-    }
-  };
-  processTxns(txnGroup, indexesToSign) {
-    const txnsToSign = [];
-    txnGroup.forEach((txn, index) => {
-      const isIndexMatch = !indexesToSign || indexesToSign.includes(index);
-      const signer = txn.sender.toString();
-      const canSignTxn = signer === this.account.addr.toString();
-      if (isIndexMatch && canSignTxn) {
-        txnsToSign.push(txn);
-      }
-    });
-    return txnsToSign;
-  }
-  processEncodedTxns(txnGroup, indexesToSign) {
-    const txnsToSign = [];
-    txnGroup.forEach((txnBuffer, index) => {
-      const decodedObj = import_algosdk10.default.msgpackRawDecode(txnBuffer);
-      const isSigned = isSignedTxn(decodedObj);
-      const txn = isSigned ? import_algosdk10.default.decodeSignedTransaction(txnBuffer).txn : import_algosdk10.default.decodeUnsignedTransaction(txnBuffer);
-      const isIndexMatch = !indexesToSign || indexesToSign.includes(index);
-      const signer = txn.sender.toString();
-      const canSignTxn = !isSigned && signer === this.account.addr.toString();
-      if (isIndexMatch && canSignTxn) {
-        txnsToSign.push(txn);
-      }
-    });
-    return txnsToSign;
-  }
-  signTransactions = async (txnGroup, indexesToSign) => {
-    this.checkMainnet();
-    try {
-      this.logger.debug("Signing transactions...", { txnGroup, indexesToSign });
-      let txnsToSign = [];
-      if (isTransactionArray(txnGroup)) {
-        const flatTxns = flattenTxnGroup(txnGroup);
-        txnsToSign = this.processTxns(flatTxns, indexesToSign);
-      } else {
-        const flatTxns = flattenTxnGroup(txnGroup);
-        txnsToSign = this.processEncodedTxns(flatTxns, indexesToSign);
-      }
-      const signedTxns = txnsToSign.map((txn) => txn.signTxn(this.account.sk));
-      this.logger.debug("Transactions signed successfully", { signedTxns });
-      return signedTxns;
-    } catch (error) {
-      this.logger.error("Error signing transactions:", error.message);
-      throw error;
-    }
-  };
-};
-
-// src/wallets/pera.ts
-var import_algosdk11 = __toESM(require("algosdk"), 1);
-var ICON13 = `data:image/svg+xml;base64,${btoa(`
 <svg viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg">
   <rect fill="#FFEE55" width="200" height="200" />
   <path fill="#1C1C1C" d="M106.1,64.3c2.2,9.1,1.5,17-1.7,17.8c-3.1,0.8-7.4-6-9.6-15c-2.2-9.1-1.5-17,1.7-17.8 C99.6,48.5,103.9,55.2,106.1,64.3z" />
@@ -8813,7 +8454,7 @@ var PeraWallet = class extends BaseWallet {
   }
   static defaultMetadata = {
     name: "Pera",
-    icon: ICON13
+    icon: ICON12
   };
   async initializeClient() {
     this.logger.info("Initializing client...");
@@ -8919,18 +8560,180 @@ var PeraWallet = class extends BaseWallet {
           prev: walletState.accounts,
           current: walletAccounts
         });
-        setAccounts(this.store, {
-          walletId: this.id,
-          accounts: walletAccounts
+        setAccounts(this.store, {
+          walletId: this.id,
+          accounts: walletAccounts
+        });
+      }
+      this.logger.info("Session resumed successfully");
+    } catch (error) {
+      this.logger.error("Error resuming session:", error.message);
+      this.onDisconnect();
+      throw error;
+    }
+  };
+  processTxns(txnGroup, indexesToSign) {
+    const txnsToSign = [];
+    txnGroup.forEach((txn, index) => {
+      const isIndexMatch = !indexesToSign || indexesToSign.includes(index);
+      const signer = txn.sender.toString();
+      const canSignTxn = this.addresses.includes(signer);
+      if (isIndexMatch && canSignTxn) {
+        txnsToSign.push({ txn });
+      } else {
+        txnsToSign.push({ txn, signers: [] });
+      }
+    });
+    return txnsToSign;
+  }
+  processEncodedTxns(txnGroup, indexesToSign) {
+    const txnsToSign = [];
+    txnGroup.forEach((txnBuffer, index) => {
+      const decodedObj = import_algosdk10.default.msgpackRawDecode(txnBuffer);
+      const isSigned = isSignedTxn(decodedObj);
+      const txn = isSigned ? import_algosdk10.default.decodeSignedTransaction(txnBuffer).txn : import_algosdk10.default.decodeUnsignedTransaction(txnBuffer);
+      const isIndexMatch = !indexesToSign || indexesToSign.includes(index);
+      const signer = txn.sender.toString();
+      const canSignTxn = !isSigned && this.addresses.includes(signer);
+      if (isIndexMatch && canSignTxn) {
+        txnsToSign.push({ txn });
+      } else {
+        txnsToSign.push({ txn, signers: [] });
+      }
+    });
+    return txnsToSign;
+  }
+  signTransactions = async (txnGroup, indexesToSign) => {
+    try {
+      this.logger.debug("Signing transactions...", { txnGroup, indexesToSign });
+      let txnsToSign = [];
+      if (isTransactionArray(txnGroup)) {
+        const flatTxns = flattenTxnGroup(txnGroup);
+        txnsToSign = this.processTxns(flatTxns, indexesToSign);
+      } else {
+        const flatTxns = flattenTxnGroup(txnGroup);
+        txnsToSign = this.processEncodedTxns(flatTxns, indexesToSign);
+      }
+      const client = this.client || await this.initializeClient();
+      this.logger.debug("Sending processed transactions to wallet...", [txnsToSign]);
+      const signedTxns = await client.signTransaction([txnsToSign]);
+      this.logger.debug("Received signed transactions from wallet", signedTxns);
+      const result = txnsToSign.reduce((acc, txn) => {
+        if (txn.signers && txn.signers.length == 0) {
+          acc.push(null);
+        } else {
+          const signedTxn = signedTxns.shift();
+          if (signedTxn) {
+            acc.push(signedTxn);
+          }
+        }
+        return acc;
+      }, []);
+      this.logger.debug("Transactions signed successfully", result);
+      return result;
+    } catch (error) {
+      this.logger.error("Error signing transactions:", error.message);
+      throw error;
+    }
+  };
+};
+
+// src/wallets/liquid-evm-base.ts
+var import_algosdk11 = __toESM(require("algosdk"), 1);
+var LiquidEvmBaseWallet = class extends BaseWallet {
+  liquidEvmSdk = null;
+  algorandClient = null;
+  evmAddressMap = /* @__PURE__ */ new Map();
+  // algorandAddress -> evmAddress
+  options;
+  store;
+  constructor(params) {
+    super(params);
+    this.options = params.options || {};
+    this.store = params.store;
+  }
+  /**
+   * Default metadata for Liquid EVM wallets.
+   * Subclasses MUST override this with their own metadata including isLiquid: "EVM"
+   */
+  static defaultMetadata;
+  /**
+   * Ensure the wallet is on the Algorand chain (4160).
+   * Queries the current chain first, and only switches/adds if needed.
+   */
+  async ensureAlgorandChain() {
+    const provider = await this.getEvmProvider();
+    const { ALGORAND_CHAIN_ID_HEX, ALGORAND_EVM_CHAIN_CONFIG } = await import("liquid-accounts-evm");
+    const currentChainId = await provider.request({ method: "eth_chainId" });
+    if (currentChainId.toLowerCase() === ALGORAND_CHAIN_ID_HEX.toLowerCase()) {
+      return;
+    }
+    this.logger.info(
+      `Wrong chain (${currentChainId}), switching to Algorand (${ALGORAND_CHAIN_ID_HEX})...`
+    );
+    try {
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: ALGORAND_CHAIN_ID_HEX }]
+      });
+    } catch (switchError) {
+      const chainUnknown = [4902, -32600, -32603].includes(switchError.code);
+      if (chainUnknown) {
+        this.logger.info("Algorand chain not found, adding it...");
+        await provider.request({
+          method: "wallet_addEthereumChain",
+          params: [ALGORAND_EVM_CHAIN_CONFIG]
+        });
+      } else {
+        throw switchError;
+      }
+    }
+  }
+  /**
+   * Initialize the Liquid EVM SDK for deriving Algorand addresses
+   */
+  async initializeEvmSdk() {
+    if (!this.liquidEvmSdk) {
+      this.logger.info("Initializing Liquid EVM SDK...");
+      if (!this.algorandClient) {
+        const { AlgorandClient } = await import("@algorandfoundation/algokit-utils");
+        const algodClient = this.getAlgodClient();
+        this.algorandClient = AlgorandClient.fromClients({
+          algod: algodClient
         });
       }
-      this.logger.info("Session resumed successfully");
-    } catch (error) {
-      this.logger.error("Error resuming session:", error.message);
-      this.onDisconnect();
-      throw error;
+      const { LiquidEvmSdk } = await import("liquid-accounts-evm");
+      this.liquidEvmSdk = new LiquidEvmSdk({ algorand: this.algorandClient });
+      this.logger.info("Liquid EVM SDK initialized");
     }
-  };
+    return this.liquidEvmSdk;
+  }
+  /**
+   * Derive Algorand accounts from EVM addresses.
+   * @param evmAddresses - EVM addresses to derive Algorand accounts from
+   * @param connectorInfo - Optional connector name/icon to include in account metadata
+   */
+  async deriveAlgorandAccounts(evmAddresses, connectorInfo) {
+    const liquidEvmSdk = await this.initializeEvmSdk();
+    const walletAccounts = [];
+    for (let i = 0; i < evmAddresses.length; i++) {
+      const evmAddress = evmAddresses[i];
+      const algorandAddress = await liquidEvmSdk.getAddress({ evmAddress });
+      this.evmAddressMap.set(algorandAddress, evmAddress);
+      const metadata = { evmAddress };
+      if (connectorInfo?.name) metadata.connectorName = connectorInfo.name;
+      if (connectorInfo?.icon) metadata.connectorIcon = connectorInfo.icon;
+      walletAccounts.push({
+        name: `${this.metadata.name} ${evmAddress}`,
+        address: algorandAddress,
+        metadata
+      });
+    }
+    return walletAccounts;
+  }
+  /**
+   * Process transaction group to extract transactions that need signing
+   */
   processTxns(txnGroup, indexesToSign) {
     const txnsToSign = [];
     txnGroup.forEach((txn, index) => {
@@ -8962,9 +8765,13 @@ var PeraWallet = class extends BaseWallet {
     });
     return txnsToSign;
   }
+  /**
+   * Sign Algorand transactions using EVM wallet signatures
+   */
   signTransactions = async (txnGroup, indexesToSign) => {
     try {
       this.logger.debug("Signing transactions...", { txnGroup, indexesToSign });
+      const liquidEvmSdk = await this.initializeEvmSdk();
       let txnsToSign = [];
       if (isTransactionArray(txnGroup)) {
         const flatTxns = flattenTxnGroup(txnGroup);
@@ -8973,136 +8780,292 @@ var PeraWallet = class extends BaseWallet {
         const flatTxns = flattenTxnGroup(txnGroup);
         txnsToSign = this.processEncodedTxns(flatTxns, indexesToSign);
       }
-      const client = this.client || await this.initializeClient();
-      this.logger.debug("Sending processed transactions to wallet...", [txnsToSign]);
-      const signedTxns = await client.signTransaction([txnsToSign]);
-      this.logger.debug("Received signed transactions from wallet", signedTxns);
-      const result = txnsToSign.reduce((acc, txn) => {
-        if (txn.signers && txn.signers.length == 0) {
-          acc.push(null);
-        } else {
-          const signedTxn = signedTxns.shift();
-          if (signedTxn) {
-            acc.push(signedTxn);
+      const firstTxn = txnsToSign[0];
+      const algorandAddress = firstTxn.txn.sender.toString();
+      let evmAddress = this.evmAddressMap.get(algorandAddress);
+      if (!evmAddress) {
+        const walletState = this.store.state.wallets[this.id];
+        if (walletState) {
+          for (const account of walletState.accounts) {
+            const addr = account.metadata?.evmAddress;
+            if (addr) {
+              this.evmAddressMap.set(account.address, addr);
+            }
           }
+          evmAddress = this.evmAddressMap.get(algorandAddress);
         }
+      }
+      if (!evmAddress) {
+        throw new Error(`No EVM address found for Algorand address: ${algorandAddress}`);
+      }
+      const onBeforeSign = this.options.uiHooks?.onBeforeSign ?? this.managerUIHooks?.onBeforeSign;
+      if (onBeforeSign) {
+        this.logger.debug("Running onBeforeSign hook", { txnGroup, indexesToSign });
+        const txnsAsUint8 = txnsToSign.map(({ txn }) => import_algosdk11.default.encodeUnsignedTransaction(txn));
+        await onBeforeSign(txnsAsUint8, indexesToSign);
+      }
+      await this.ensureAlgorandChain();
+      const { signer: evmSigner } = await liquidEvmSdk.getSigner({
+        evmAddress,
+        signMessage: (typedData) => this.signWithProvider(typedData, evmAddress)
+      });
+      const allTxns = txnsToSign.map((t) => t.txn);
+      const signIndexes = txnsToSign.reduce((acc, t, i) => {
+        if (!("signers" in t)) acc.push(i);
         return acc;
       }, []);
+      const signedBlobs = await evmSigner(allTxns, signIndexes);
+      const onAfterSign = this.options.uiHooks?.onAfterSign ?? this.managerUIHooks?.onAfterSign;
+      if (onAfterSign) {
+        this.logger.debug("Running onAfterSign hook");
+        try {
+          onAfterSign(true);
+        } catch (e) {
+        }
+      }
+      let signedIdx = 0;
+      const result = txnsToSign.map((_2, index) => {
+        if (signIndexes.includes(index)) {
+          return signedBlobs[signedIdx++];
+        }
+        return null;
+      });
       this.logger.debug("Transactions signed successfully", result);
       return result;
     } catch (error) {
+      try {
+        const onAfterSignCleanup = this.options.uiHooks?.onAfterSign ?? this.managerUIHooks?.onAfterSign;
+        onAfterSignCleanup?.(false, error.message);
+      } catch (e) {
+      }
       this.logger.error("Error signing transactions:", error.message);
       throw error;
     }
   };
+  /**
+   * Helper to compare and update accounts if needed during session resume
+   */
+  async resumeWithAccounts(evmAddresses, setAccountsFn, connectorInfo) {
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    if (!walletState) {
+      this.logger.info("No session to resume");
+      return;
+    }
+    for (const account of walletState.accounts) {
+      const evmAddr = account.metadata?.evmAddress;
+      if (evmAddr) {
+        this.evmAddressMap.set(account.address, evmAddr);
+      }
+    }
+    const walletAccounts = await this.deriveAlgorandAccounts(evmAddresses, connectorInfo);
+    const match = compareAccounts(walletAccounts, walletState.accounts);
+    if (!match) {
+      this.logger.warn("Session accounts mismatch, updating accounts", {
+        prev: walletState.accounts,
+        current: walletAccounts
+      });
+    }
+    setAccountsFn(walletAccounts);
+    this.logger.info("Session resumed");
+  }
+  notifyConnect(evmAddress, algorandAddress) {
+    const onConnect = this.options.uiHooks?.onConnect ?? this.managerUIHooks?.onConnect;
+    if (onConnect) {
+      onConnect({ evmAddress, algorandAddress });
+    }
+  }
 };
 
-// src/wallets/rainbow.ts
-var ICON14 = `data:image/svg+xml;base64,${btoa(`
+// src/wallets/rainbowkit.ts
+var import_liquid_accounts_evm = require("liquid-accounts-evm");
+var ICON13 = `data:image/svg+xml;base64,${btoa(`
 <svg width="120" height="120" viewBox="0 0 120 120" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <rect width="120" height="120" rx="60" fill="url(#paint0_linear)"/>
-  <path d="M60 85C74.9117 85 87 72.9117 87 58C87 43.0883 74.9117 31 60 31C45.0883 31 33 43.0883 33 58C33 72.9117 45.0883 85 60 85Z" fill="white"/>
-  <path d="M60 77C70.4934 77 79 68.4934 79 58C79 47.5066 70.4934 39 60 39C49.5066 39 41 47.5066 41 58C41 68.4934 49.5066 77 60 77Z" fill="url(#paint1_linear)"/>
+  <rect width="120" height="120" rx="24" fill="url(#rk_bg)"/>
+  <path d="M24 86V76.8C24 55.9 40.9 39 61.8 39H66C70.418 39 74 42.582 74 47V86" stroke="#FF4000" stroke-width="8" stroke-linecap="round" fill="none"/>
+  <path d="M36 86V76.8C36 62.3 47.7 50.6 62.2 50.6H64C67.314 50.6 70 53.286 70 56.6V86" stroke="#FF9500" stroke-width="8" stroke-linecap="round" fill="none"/>
+  <path d="M48 86V76.8C48 68.8 54.5 62.3 62.5 62.3H62.7C65.461 62.3 67.7 64.539 67.7 67.3V86" stroke="#00C853" stroke-width="8" stroke-linecap="round" fill="none"/>
+  <path d="M60 86V76.8C60 75 61.5 73.5 63.3 73.5C65.1 73.5 66.6 75 66.6 76.8V86" stroke="#2979FF" stroke-width="8" stroke-linecap="round" fill="none"/>
   <defs>
-    <linearGradient id="paint0_linear" x1="0" y1="0" x2="120" y2="120" gradientUnits="userSpaceOnUse">
-      <stop stop-color="#174299"/>
-      <stop offset="1" stop-color="#001E59"/>
-    </linearGradient>
-    <linearGradient id="paint1_linear" x1="41" y1="39" x2="79" y2="77" gradientUnits="userSpaceOnUse">
-      <stop stop-color="#FF4444"/>
-      <stop offset="0.2" stop-color="#FF8844"/>
-      <stop offset="0.4" stop-color="#FFDD00"/>
-      <stop offset="0.6" stop-color="#44FF44"/>
-      <stop offset="0.8" stop-color="#0088FF"/>
-      <stop offset="1" stop-color="#8844FF"/>
+    <linearGradient id="rk_bg" x1="0" y1="0" x2="120" y2="120">
+      <stop stop-color="#1A1B23"/>
+      <stop offset="1" stop-color="#13141B"/>
     </linearGradient>
   </defs>
 </svg>
 `)}`;
-var RainbowWallet = class extends LiquidEvmBaseWallet {
-  provider = null;
+var RainbowKitWallet = class _RainbowKitWallet extends LiquidEvmBaseWallet {
   options;
+  _connecting = false;
   constructor(params) {
     super(params);
     this.options = params.options || {};
+    if (!this.options.wagmiConfig) {
+      throw new Error("RainbowKitWallet requires wagmiConfig in options");
+    }
+    this.ensureChainRegistered();
   }
   static defaultMetadata = {
-    name: "Rainbow",
-    icon: ICON14,
+    name: "EVM Wallet",
+    icon: ICON13,
     isLiquid: "EVM"
   };
-  async initializeProvider() {
-    if (typeof window === "undefined") {
-      throw new Error("Rainbow wallet only works in browser environment");
-    }
-    const windowEth = window.ethereum;
-    if (window.rainbow) {
-      this.logger.info("Found Rainbow browser extension at window.rainbow");
-      return;
-    }
-    if (windowEth?.providers && Array.isArray(windowEth.providers)) {
-      const rainbowProvider = windowEth.providers.find((p2) => p2.isRainbow);
-      if (rainbowProvider) {
-        this.logger.info("Found Rainbow in providers array");
-        return;
-      }
-    }
-    if (windowEth?.isRainbow) {
-      this.logger.info("Found Rainbow as the primary provider");
+  /** True while connect() is running. Prevents re-entrancy from bridge components. */
+  get isConnecting() {
+    return this._connecting;
+  }
+  /**
+   * Set the getEvmAccounts callback after construction.
+   *
+   * RainbowKit's connect modal can only be opened via React hooks (useConnectModal)
+   * rendered inside <RainbowKitProvider>, but WalletManager is constructed before
+   * any React tree renders. This method lets WalletUIProvider create the bridge
+   * callback internally and inject it into the wallet on mount — before any
+   * user-initiated connect() call.
+   */
+  setGetEvmAccounts(fn) {
+    this.options.getEvmAccounts = fn;
+  }
+  get wagmiConfig() {
+    return this.options.wagmiConfig;
+  }
+  /**
+   * If the Algorand chain (4160) isn't already in the wagmi config, add it.
+   * This is needed so wagmi's switchChain and signTypedData work without
+   * falling back to raw provider calls.
+   */
+  ensureChainRegistered() {
+    const chains = this.wagmiConfig.chains;
+    if (chains.some((c) => c.id === import_liquid_accounts_evm.ALGORAND_CHAIN_ID)) {
       return;
     }
-    this.logger.warn("Rainbow extension not detected. Note: Rainbow mobile app requires WalletConnect.");
+    this.logger.info(`Registering Algorand chain (${import_liquid_accounts_evm.ALGORAND_CHAIN_ID}) in wagmi config`);
+    chains.push(import_liquid_accounts_evm.algorandChain);
+  }
+  async initializeProvider() {
+    this.logger.info("Using wagmi for EVM provider management");
+  }
+  /**
+   * Get the raw EIP-1193 provider from the active wagmi connector.
+   * Used by the base class's getEvmProvider and ensureAlgorandChain.
+   */
+  async getRawProvider() {
+    const { getAccount } = await import("@wagmi/core");
+    const account = getAccount(this.wagmiConfig);
+    if (!account.connector) throw new Error("No EVM wallet connector available");
+    return account.connector.getProvider();
   }
   async getEvmProvider() {
-    if (!this.provider) {
-      await this.initializeProvider();
-      const windowEth = window.ethereum;
-      if (window.rainbow) {
-        this.provider = window.rainbow;
-      } else if (windowEth?.providers && Array.isArray(windowEth.providers)) {
-        const rainbowProvider = windowEth.providers.find((p2) => p2.isRainbow);
-        if (rainbowProvider) {
-          this.provider = rainbowProvider;
+    return this.getRawProvider();
+  }
+  /**
+   * Sign EIP-712 typed data using wagmi's signTypedData.
+   *
+   * wagmi's signTypedData does NOT validate the domain's chainId against the
+   * connected chain — it simply forwards the typed data to the wallet via viem.
+   * EIP-712 signing is chain-agnostic (the chain ID is in the typed data domain,
+   * not in the RPC method), so this works regardless of which chain the wallet
+   * reports being on.
+   */
+  async signWithProvider(typedData, evmAddress) {
+    const { signTypedData } = await import("@wagmi/core");
+    const { EIP712Domain: _2, ...types } = typedData.types;
+    return signTypedData(this.wagmiConfig, {
+      account: evmAddress,
+      domain: typedData.domain,
+      types,
+      primaryType: typedData.primaryType,
+      message: typedData.message
+    });
+  }
+  /**
+   * Build a connectorInfo object from a wagmi account, omitting undefined fields.
+   * Uses `any` for the parameter to avoid exactOptionalPropertyTypes conflicts
+   * with wagmi's discriminated union return types.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static extractConnectorInfo(account) {
+    const info = {};
+    const connector = account?.connector;
+    if (typeof connector?.name === "string") info.name = connector.name;
+    if (typeof connector?.icon === "string") info.icon = connector.icon;
+    return info;
+  }
+  /**
+   * Read connected EVM accounts from wagmi state.
+   * If not connected, tries the getEvmAccounts callback, then falls back to
+   * connecting with the first available connector.
+   *
+   * When getEvmAccounts is provided, it is always called (to show the wallet
+   * selection UI). The callback is responsible for any disconnect/reconnect
+   * needed to present a fresh selection.
+   */
+  async getConnectedEvmAddresses() {
+    const { getAccount, connect: wagmiConnect } = await import("@wagmi/core");
+    if (this.options.getEvmAccounts) {
+      const addresses = await this.options.getEvmAccounts();
+      if (addresses.length > 0) {
+        const account2 = getAccount(this.wagmiConfig);
+        const connectorInfo = _RainbowKitWallet.extractConnectorInfo(account2);
+        if (account2.isConnected && account2.address) {
+          return {
+            addresses: account2.addresses ? [...account2.addresses] : [account2.address],
+            connectorInfo
+          };
         }
-      } else if (windowEth?.isRainbow) {
-        this.provider = windowEth;
+        return { addresses, connectorInfo };
       }
-      if (!this.provider) {
-        throw new Error("Rainbow wallet not available. Please install Rainbow browser extension or use WalletConnect for mobile.");
+    }
+    const account = getAccount(this.wagmiConfig);
+    if (account.isConnected && account.address) {
+      return {
+        addresses: account.addresses ? [...account.addresses] : [account.address],
+        connectorInfo: _RainbowKitWallet.extractConnectorInfo(account)
+      };
+    }
+    const connectors = this.wagmiConfig.connectors;
+    if (connectors.length > 0) {
+      this.logger.info("Attempting connection with first available connector...");
+      try {
+        const result = await wagmiConnect(this.wagmiConfig, { connector: connectors[0] });
+        const updatedAccount = getAccount(this.wagmiConfig);
+        return {
+          addresses: [...result.accounts],
+          connectorInfo: _RainbowKitWallet.extractConnectorInfo(updatedAccount)
+        };
+      } catch (error) {
+        this.logger.warn("Auto-connect failed:", error.message);
       }
     }
-    return this.provider;
+    throw new Error("No EVM wallet connected. Please connect an EVM wallet first.");
   }
-  async signWithProvider(typedData, evmAddress) {
-    const provider = await this.getEvmProvider();
-    try {
-      return await provider.request({
-        method: "eth_signTypedData_v4",
-        params: [evmAddress, JSON.stringify(typedData)]
-      });
-    } catch (error) {
-      if (error.code === 4001) {
-        throw new Error("User rejected the signing request");
-      }
-      throw error;
+  /**
+   * Apply connector info to wallet-level metadata so the UI displays
+   * the actual wallet name/icon (e.g., "MetaMask") instead of the generic
+   * "EVM Wallet".  Falls back to defaults when connector info is unavailable.
+   */
+  applyConnectorMetadata(connectorInfo) {
+    const updates = {};
+    if (connectorInfo.name) updates.name = connectorInfo.name;
+    if (connectorInfo.icon) updates.icon = connectorInfo.icon;
+    if (updates.name || updates.icon) {
+      this.updateMetadata(updates);
+      this.logger.info(`Wallet metadata updated: ${updates.name ?? "(no name)"}`);
     }
   }
   connect = async () => {
-    this.logger.info("Connecting...");
-    await this.initializeProvider();
-    await this.initializeEvmSdk();
-    const provider = await this.getEvmProvider();
+    if (this._connecting) {
+      this.logger.info("connect() already in progress, ignoring duplicate call");
+      return [];
+    }
+    this._connecting = true;
     try {
-      this.logger.info("Requesting Rainbow wallet connection...");
-      const evmAddresses = await provider.request({
-        method: "eth_requestAccounts"
-      });
-      if (evmAddresses.length === 0) {
-        this.logger.error("No accounts found!");
-        throw new Error("No accounts found!");
-      }
+      this.logger.info("Connecting...");
+      await this.initializeEvmSdk();
+      const { addresses: evmAddresses, connectorInfo } = await this.getConnectedEvmAddresses();
       this.logger.info(`Connected to ${evmAddresses.length} EVM account(s)`);
-      const walletAccounts = await this.deriveAlgorandAccounts(evmAddresses);
+      this.applyConnectorMetadata(connectorInfo);
+      const walletAccounts = await this.deriveAlgorandAccounts(evmAddresses, connectorInfo);
       const activeAccount = walletAccounts[0];
       const walletState = {
         accounts: walletAccounts,
@@ -9112,51 +9075,70 @@ var RainbowWallet = class extends LiquidEvmBaseWallet {
         walletId: this.id,
         wallet: walletState
       });
-      this.logger.info("\u2705 Connected.", walletState);
+      this.logger.info("Connected.", walletState);
       this.notifyConnect(evmAddresses[0], activeAccount.address);
       return walletAccounts;
-    } catch (error) {
-      this.logger.error("Error connecting:", error.message);
-      throw error;
+    } finally {
+      this._connecting = false;
     }
   };
   disconnect = async () => {
     this.logger.info("Disconnecting...");
-    this.provider = null;
+    try {
+      const { disconnect: wagmiDisconnect } = await import("@wagmi/core");
+      await wagmiDisconnect(this.wagmiConfig);
+    } catch (error) {
+      this.logger.warn("wagmi disconnect error:", error.message);
+    }
     this.evmAddressMap.clear();
+    this.updateMetadata(_RainbowKitWallet.defaultMetadata);
     this.onDisconnect();
     this.logger.info("Disconnected");
   };
   resumeSession = async () => {
+    const state = this.store.state;
+    const walletState = state.wallets[this.id];
+    if (!walletState) {
+      return;
+    }
+    this.logger.info("Resuming session...");
+    await this.initializeEvmSdk();
+    const { getAccount, reconnect } = await import("@wagmi/core");
     try {
-      const state = this.store.state;
-      const walletState = state.wallets[this.id];
-      if (!walletState) {
-        this.logger.info("No session to resume");
-        return;
-      }
-      this.logger.info("Resuming session...");
-      await this.initializeProvider();
-      await this.initializeEvmSdk();
-      const provider = await this.getEvmProvider();
-      const evmAddresses = await provider.request({
-        method: "eth_accounts"
-      });
+      await reconnect(this.wagmiConfig);
+    } catch (err) {
+      this.logger.warn("wagmi reconnect error (may be expected):", err.message);
+    }
+    const account = getAccount(this.wagmiConfig);
+    let evmAddresses;
+    let connectorInfo;
+    if (account.isConnected && account.address) {
+      evmAddresses = account.addresses ? [...account.addresses] : [account.address];
+      connectorInfo = _RainbowKitWallet.extractConnectorInfo(account);
+    } else {
+      this.logger.warn("EVM wallet not yet connected, resuming from persisted state");
+      evmAddresses = walletState.accounts.map((a) => a.metadata?.evmAddress).filter(Boolean);
       if (evmAddresses.length === 0) {
-        this.logger.error("No accounts found!");
-        throw new Error("No accounts found!");
+        this.logger.warn("No persisted EVM addresses, cannot resume");
+        this.onDisconnect();
+        return;
       }
-      await this.resumeWithAccounts(evmAddresses, (accounts) => {
-        setAccounts(this.store, {
-          walletId: this.id,
-          accounts
-        });
-      });
-    } catch (error) {
-      this.logger.error("Error resuming session:", error.message);
-      this.onDisconnect();
-      throw error;
+      connectorInfo = {};
     }
+    if (!connectorInfo.name && walletState.accounts.length > 0) {
+      const first = walletState.accounts[0];
+      const persistedName = first.metadata?.connectorName;
+      const persistedIcon = first.metadata?.connectorIcon;
+      if (persistedName) connectorInfo.name = persistedName;
+      if (persistedIcon) connectorInfo.icon = persistedIcon;
+    }
+    this.applyConnectorMetadata(connectorInfo);
+    await this.resumeWithAccounts(evmAddresses, (accounts) => {
+      setAccounts(this.store, {
+        walletId: this.id,
+        accounts
+      });
+    }, connectorInfo);
   };
 };
 
@@ -9273,7 +9255,7 @@ async function deriveAlgorandAccountFromEd25519(ed25519Seed) {
 
 // src/wallets/web3auth.ts
 var LOCAL_STORAGE_WEB3AUTH_KEY = `${LOCAL_STORAGE_KEY}:web3auth`;
-var ICON15 = `data:image/svg+xml;base64,${btoa(`
+var ICON14 = `data:image/svg+xml;base64,${btoa(`
 <svg viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg">
   <rect fill="#0364FF" width="40" height="40" rx="8"/>
   <path fill="#FFFFFF" d="M20 8c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12S26.627 8 20 8zm0 21.6c-5.302 0-9.6-4.298-9.6-9.6S14.698 10.4 20 10.4s9.6 4.298 9.6 9.6-4.298 9.6-9.6 9.6zm0-16.8c-3.976 0-7.2 3.224-7.2 7.2s3.224 7.2 7.2 7.2 7.2-3.224 7.2-7.2-3.224-7.2-7.2-7.2zm0 12c-2.651 0-4.8-2.149-4.8-4.8s2.149-4.8 4.8-4.8 4.8 2.149 4.8 4.8-2.149 4.8-4.8 4.8z"/>
@@ -9330,7 +9312,7 @@ var Web3AuthWallet = class extends BaseWallet {
   }
   static defaultMetadata = {
     name: "Web3Auth",
-    icon: ICON15
+    icon: ICON14
   };
   /**
    * Initialize the Web3Auth client
@@ -9839,7 +9821,7 @@ var Web3AuthWallet = class extends BaseWallet {
 
 // src/wallets/w3wallet.ts
 var import_algosdk13 = __toESM(require("algosdk"), 1);
-var ICON16 = `data:image/svg+xml;base64,${btoa(`
+var ICON15 = `data:image/svg+xml;base64,${btoa(`
 <svg width="860" height="860" viewBox="0 0 860 860" fill="none" xmlns="http://www.w3.org/2000/svg">
   <rect width="860" height="860" rx="30" fill="#151923"/>
   <path d="M766 207L496.627 623.406C463.521 675.336 382.014 652.248 382.014 590.941V432.568L260.638 623.28C227.559 675.255 146 652.186 146 590.854V274.844H234.646V499.761L356.022 309.049C389.101 257.074 470.66 280.143 470.66 341.475V499.978L660.146 207L766 207Z" fill="#4BB7D1"/>
@@ -9860,7 +9842,7 @@ var W3Wallet = class extends BaseWallet {
   }
   static defaultMetadata = {
     name: "W3 Wallet",
-    icon: ICON16
+    icon: ICON15
   };
   async initializeClient() {
     this.logger.info("Initializing client...");
@@ -9990,10 +9972,9 @@ function createWalletMap() {
     ["kmd" /* KMD */]: KmdWallet,
     ["lute" /* LUTE */]: LuteWallet,
     ["magic" /* MAGIC */]: MagicAuth,
-    ["metamask" /* METAMASK */]: MetaMaskWallet,
     ["mnemonic" /* MNEMONIC */]: MnemonicWallet,
     ["pera" /* PERA */]: PeraWallet,
-    ["rainbow" /* RAINBOW */]: RainbowWallet,
+    ["rainbowkit" /* RAINBOWKIT */]: RainbowKitWallet,
     ["walletconnect" /* WALLETCONNECT */]: WalletConnect,
     ["web3auth" /* WEB3AUTH */]: Web3AuthWallet,
     ["w3-wallet" /* W3_WALLET */]: W3Wallet
@@ -10114,7 +10095,7 @@ var WalletManager = class {
       activeNetwork,
       algodClient
     };
-    this.store = new import_store16.Store(initialState, {
+    this.store = new import_store15.Store(initialState, {
       onUpdate: () => this.savePersistedState()
     });
     this.savePersistedState();
@@ -10487,12 +10468,11 @@ var webpackFallback = {
   LogLevel,
   LuteWallet,
   MagicAuth,
-  MetaMaskWallet,
   MnemonicWallet,
   NetworkConfigBuilder,
   NetworkId,
   PeraWallet,
-  RainbowWallet,
+  RainbowKitWallet,
   ScopeType,
   SecureKeyContainer,
   SessionError,